core.sys.posix.signal source code

1 /**
2  * D header file for POSIX.
3  *
4  * Copyright: Copyright Sean Kelly 2005 - 2009.
5  * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
6  * Authors:   Sean Kelly,
7               Alex Rønne Petersen
8  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
9  * Source:    $(DRUNTIMESRC core/sys/posix/_signal.d)
10  */
11 
12 module core.sys.posix.signal;
13 
14 import core.sys.posix.config;
15 public import core.stdc.signal;
16 public import core.sys.posix.sys.types; // for pid_t
17 public import core.sys.posix.time; // for timespec
18 
19 version (OSX)
20     version = Darwin;
21 else version (iOS)
22     version = Darwin;
23 else version (TVOS)
24     version = Darwin;
25 else version (WatchOS)
26     version = Darwin;
27 
28 version (ARM)     version = ARM_Any;
29 version (AArch64) version = ARM_Any;
30 version (HPPA)    version = HPPA_Any;
31 version (MIPS32)  version = MIPS_Any;
32 version (MIPS64)  version = MIPS_Any;
33 version (PPC)     version = PPC_Any;
34 version (PPC64)   version = PPC_Any;
35 version (RISCV32) version = RISCV_Any;
36 version (RISCV64) version = RISCV_Any;
37 version (S390)    version = IBMZ_Any;
38 version (SPARC)   version = SPARC_Any;
39 version (SPARC64) version = SPARC_Any;
40 version (SystemZ) version = IBMZ_Any;
41 version (X86)     version = X86_Any;
42 version (X86_64)  version = X86_Any;
43 
44 version (Posix):
45 extern (C):
46 //nothrow:  // this causes http://issues.dlang.org/show_bug.cgi?id=12738 (which has been fixed)
47 //@system:
48 
49 //
50 // Required
51 //
52 /*
53 SIG_DFL (defined in core.stdc.signal)
54 SIG_ERR (defined in core.stdc.signal)
55 SIG_IGN (defined in core.stdc.signal)
56 
57 sig_atomic_t (defined in core.stdc.signal)
58 
59 SIGEV_NONE
60 SIGEV_SIGNAL
61 SIGEV_THREAD
62 
63 union sigval
64 {
65     int   sival_int;
66     void* sival_ptr;
67 }
68 
69 SIGRTMIN
70 SIGRTMAX
71 
72 SIGABRT (defined in core.stdc.signal)
73 SIGALRM
74 SIGBUS
75 SIGCHLD
76 SIGCONT
77 SIGFPE (defined in core.stdc.signal)
78 SIGHUP
79 SIGILL (defined in core.stdc.signal)
80 SIGINT (defined in core.stdc.signal)
81 SIGKILL
82 SIGPIPE
83 SIGQUIT
84 SIGSEGV (defined in core.stdc.signal)
85 SIGSTOP
86 SIGTERM (defined in core.stdc.signal)
87 SIGTSTP
88 SIGTTIN
89 SIGTTOU
90 SIGUSR1
91 SIGUSR2
92 SIGURG
93 
94 struct sigaction_t
95 {
96     sigfn_t     sa_handler;
97     sigset_t    sa_mask;
98     sigactfn_t  sa_sigaction;
99 }
100 
101 sigfn_t signal(int sig, sigfn_t func); (defined in core.stdc.signal)
102 int raise(int sig);                    (defined in core.stdc.signal)
103 */
104 
105 //SIG_DFL (defined in core.stdc.signal)
106 //SIG_ERR (defined in core.stdc.signal)
107 //SIG_IGN (defined in core.stdc.signal)
108 
109 //sig_atomic_t (defined in core.stdc.signal)
110 
111 private alias void function(int) sigfn_t;
112 private alias void function(int, siginfo_t*, void*) sigactfn_t;
113 
114 // nothrow versions
115 nothrow @nogc
116 {
117     private alias void function(int) sigfn_t2;
118     private alias void function(int, siginfo_t*, void*) sigactfn_t2;
119 }
120 
121 enum
122 {
123   SIGEV_SIGNAL,
124   SIGEV_NONE,
125   SIGEV_THREAD
126 }
127 
128 union sigval
129 {
130     int     sival_int;
131     void*   sival_ptr;
132 }
133 
134 version (Solaris)
135 {
136     import core.sys.posix.unistd;
137 
138     @property int SIGRTMIN() nothrow @nogc {
139         __gshared static int sig = -1;
140         if (sig == -1) {
141             sig = cast(int)sysconf(_SC_SIGRT_MIN);
142         }
143         return sig;
144     }
145 
146     @property int SIGRTMAX() nothrow @nogc {
147         __gshared static int sig = -1;
148         if (sig == -1) {
149             sig = cast(int)sysconf(_SC_SIGRT_MAX);
150         }
151         return sig;
152     }
153 }
154 else version (FreeBSD)
155 {
156     // Note: it appears that FreeBSD (prior to 7) and OSX do not support realtime signals
157     // https://github.com/freebsd/freebsd/blob/e79c62ff68fc74d88cb6f479859f6fae9baa5101/sys/sys/signal.h#L117
158     enum SIGRTMIN = 65;
159     enum SIGRTMAX = 126;
160 }
161 else version (DragonFlyBSD)
162 {
163     enum SIGRTMIN = 35;
164     enum SIGRTMAX = 126;
165 }
166 else version (NetBSD)
167 {
168     enum SIGRTMIN = 33;
169     enum SIGRTMAX = 63;
170 }
171 else version (linux)
172 {
173     // Note: CRuntime_Bionic switched to calling these functions
174     // since Lollipop, and Glibc, UClib and Musl all implement them
175     // the same way since it's part of LSB.
176     private extern (C) nothrow @nogc
177     {
178         int __libc_current_sigrtmin();
179         int __libc_current_sigrtmax();
180     }
181 
182     @property int SIGRTMIN() nothrow @nogc @system {
183         __gshared static int sig = -1;
184         if (sig == -1) {
185             sig = __libc_current_sigrtmin();
186         }
187         return sig;
188     }
189 
190     @property int SIGRTMAX() nothrow @nogc @system {
191         __gshared static int sig = -1;
192         if (sig == -1) {
193             sig = __libc_current_sigrtmax();
194         }
195         return sig;
196     }
197 }
198 
199 version (linux)
200 {
201     version (X86_Any)
202     {
203         //SIGABRT (defined in core.stdc.signal)
204         enum SIGALRM    = 14;
205         enum SIGBUS     = 7;
206         enum SIGCHLD    = 17;
207         enum SIGCONT    = 18;
208         //SIGFPE (defined in core.stdc.signal)
209         enum SIGHUP     = 1;
210         //SIGILL (defined in core.stdc.signal)
211         //SIGINT (defined in core.stdc.signal)
212         enum SIGKILL    = 9;
213         enum SIGPIPE    = 13;
214         enum SIGQUIT    = 3;
215         //SIGSEGV (defined in core.stdc.signal)
216         enum SIGSTOP    = 19;
217         //SIGTERM (defined in core.stdc.signal)
218         enum SIGTSTP    = 20;
219         enum SIGTTIN    = 21;
220         enum SIGTTOU    = 22;
221         enum SIGUSR1    = 10;
222         enum SIGUSR2    = 12;
223         enum SIGURG     = 23;
224     }
225     else version (HPPA_Any)
226     {
227         //SIGABRT (defined in core.stdc.signal)
228         enum SIGALRM    = 14;
229         enum SIGBUS     = 10;
230         enum SIGCHLD    = 18;
231         enum SIGCONT    = 26;
232         //SIGFPE (defined in core.stdc.signal)
233         enum SIGHUP     = 1;
234         //SIGILL (defined in core.stdc.signal)
235         //SIGINT (defined in core.stdc.signal)
236         enum SIGKILL    = 9;
237         enum SIGPIPE    = 13;
238         enum SIGQUIT    = 3;
239         //SIGSEGV (defined in core.stdc.signal)
240         enum SIGSTOP    = 24;
241         //SIGTERM (defined in core.stdc.signal)
242         enum SIGTSTP    = 25;
243         enum SIGTTIN    = 27;
244         enum SIGTTOU    = 28;
245         enum SIGUSR1    = 16;
246         enum SIGUSR2    = 17;
247         enum SIGURG     = 29;
248     }
249     else version (MIPS_Any)
250     {
251         //SIGABRT (defined in core.stdc.signal)
252         enum SIGALRM    = 14;
253         enum SIGBUS     = 10;
254         enum SIGCHLD    = 18;
255         enum SIGCONT    = 25;
256         //SIGFPE (defined in core.stdc.signal)
257         enum SIGHUP     = 1;
258         //SIGILL (defined in core.stdc.signal)
259         //SIGINT (defined in core.stdc.signal)
260         enum SIGKILL    = 9;
261         enum SIGPIPE    = 13;
262         enum SIGQUIT    = 3;
263         //SIGSEGV (defined in core.stdc.signal)
264         enum SIGSTOP    = 23;
265         //SIGTERM (defined in core.stdc.signal)
266         enum SIGTSTP    = 24;
267         enum SIGTTIN    = 26;
268         enum SIGTTOU    = 27;
269         enum SIGUSR1    = 16;
270         enum SIGUSR2    = 17;
271         enum SIGURG     = 21;
272     }
273     else version (PPC_Any)
274     {
275         //SIGABRT (defined in core.stdc.signal)
276         enum SIGALRM    = 14;
277         enum SIGBUS     = 7;
278         enum SIGCHLD    = 17;
279         enum SIGCONT    = 18;
280         //SIGFPE (defined in core.stdc.signal)
281         enum SIGHUP     = 1;
282         //SIGILL (defined in core.stdc.signal)
283         //SIGINT (defined in core.stdc.signal)
284         enum SIGKILL    = 9;
285         enum SIGPIPE    = 13;
286         enum SIGQUIT    = 3;
287         //SIGSEGV (defined in core.stdc.signal)
288         enum SIGSTOP    = 19;
289         //SIGTERM (defined in core.stdc.signal)
290         enum SIGTSTP    = 20;
291         enum SIGTTIN    = 21;
292         enum SIGTTOU    = 22;
293         enum SIGUSR1    = 10;
294         enum SIGUSR2    = 12;
295         enum SIGURG     = 23;
296     }
297     else version (ARM_Any)
298     {
299         //SIGABRT (defined in core.stdc.signal)
300         enum SIGALRM    = 14;
301         enum SIGBUS     = 7;
302         enum SIGCHLD    = 17;
303         enum SIGCONT    = 18;
304         //SIGFPE (defined in core.stdc.signal)
305         enum SIGHUP     = 1;
306         //SIGILL (defined in core.stdc.signal)
307         //SIGINT (defined in core.stdc.signal)
308         enum SIGKILL    = 9;
309         enum SIGPIPE    = 13;
310         enum SIGQUIT    = 3;
311         //SIGSEGV (defined in core.stdc.signal)
312         enum SIGSTOP    = 19;
313         //SIGTERM (defined in core.stdc.signal)
314         enum SIGTSTP    = 20;
315         enum SIGTTIN    = 21;
316         enum SIGTTOU    = 22;
317         enum SIGUSR1    = 10;
318         enum SIGUSR2    = 12;
319         enum SIGURG     = 23;
320     }
321     else version (RISCV_Any)
322     {
323         //SIGABRT (defined in core.stdc.signal)
324         enum SIGALRM    = 14;
325         enum SIGBUS     = 7;
326         enum SIGCHLD    = 17;
327         enum SIGCONT    = 18;
328         //SIGFPE (defined in core.stdc.signal)
329         enum SIGHUP     = 1;
330         //SIGILL (defined in core.stdc.signal)
331         //SIGINT (defined in core.stdc.signal)
332         enum SIGKILL    = 9;
333         enum SIGPIPE    = 13;
334         enum SIGQUIT    = 3;
335         //SIGSEGV (defined in core.stdc.signal)
336         enum SIGSTOP    = 19;
337         //SIGTERM (defined in core.stdc.signal)
338         enum SIGTSTP    = 20;
339         enum SIGTTIN    = 21;
340         enum SIGTTOU    = 22;
341         enum SIGUSR1    = 10;
342         enum SIGUSR2    = 12;
343         enum SIGURG     = 23;
344     }
345     else version (SPARC_Any)
346     {
347         //SIGABRT (defined in core.stdc.signal)
348         enum SIGALRM    = 14;
349         enum SIGBUS     = 10;
350         enum SIGCHLD    = 20;
351         enum SIGCONT    = 19;
352         //SIGFPE (defined in core.stdc.signal)
353         enum SIGHUP     = 1;
354         //SIGILL (defined in core.stdc.signal)
355         //SIGINT (defined in core.stdc.signal)
356         enum SIGKILL    = 9;
357         enum SIGPIPE    = 13;
358         enum SIGQUIT    = 3;
359         //SIGSEGV (defined in core.stdc.signal)
360         enum SIGSTOP    = 17;
361         //SIGTERM (defined in core.stdc.signal)
362         enum SIGTSTP    = 18;
363         enum SIGTTIN    = 21;
364         enum SIGTTOU    = 22;
365         enum SIGUSR1    = 30;
366         enum SIGUSR2    = 31;
367         enum SIGURG     = 16;
368     }
369     else version (IBMZ_Any)
370     {
371         //SIGABRT (defined in core.stdc.signal)
372         enum SIGALRM    = 14;
373         enum SIGBUS     = 7;
374         enum SIGCHLD    = 17;
375         enum SIGCONT    = 18;
376         //SIGFPE (defined in core.stdc.signal)
377         enum SIGHUP     = 1;
378         //SIGILL (defined in core.stdc.signal)
379         //SIGINT (defined in core.stdc.signal)
380         enum SIGKILL    = 9;
381         enum SIGPIPE    = 13;
382         enum SIGQUIT    = 3;
383         //SIGSEGV (defined in core.stdc.signal)
384         enum SIGSTOP    = 19;
385         //SIGTERM (defined in core.stdc.signal)
386         enum SIGTSTP    = 20;
387         enum SIGTTIN    = 21;
388         enum SIGTTOU    = 22;
389         enum SIGUSR1    = 10;
390         enum SIGUSR2    = 12;
391         enum SIGURG     = 23;
392     }
393     else version (LoongArch64)
394     {
395         //SIGABRT (defined in core.stdc.signal)
396         enum SIGALRM    = 14;
397         enum SIGBUS     = 7;
398         enum SIGCHLD    = 17;
399         enum SIGCONT    = 18;
400         //SIGFPE (defined in core.stdc.signal)
401         enum SIGHUP     = 1;
402         //SIGILL (defined in core.stdc.signal)
403         //SIGINT (defined in core.stdc.signal)
404         enum SIGKILL    = 9;
405         enum SIGPIPE    = 13;
406         enum SIGQUIT    = 3;
407         //SIGSEGV (defined in core.stdc.signal)
408         enum SIGSTOP    = 19;
409         //SIGTERM (defined in core.stdc.signal)
410         enum SIGTSTP    = 20;
411         enum SIGTTIN    = 21;
412         enum SIGTTOU    = 22;
413         enum SIGUSR1    = 10;
414         enum SIGUSR2    = 12;
415         enum SIGURG     = 23;
416     }
417     else version (WebAssembly)
418     {
419     	// FIXME: verify
420         //SIGABRT (defined in core.stdc.signal)
421         enum SIGALRM    = 14;
422         enum SIGBUS     = 7;
423         enum SIGCHLD    = 17;
424         enum SIGCONT    = 18;
425         //SIGFPE (defined in core.stdc.signal)
426         enum SIGHUP     = 1;
427         //SIGILL (defined in core.stdc.signal)
428         //SIGINT (defined in core.stdc.signal)
429         enum SIGKILL    = 9;
430         enum SIGPIPE    = 13;
431         enum SIGQUIT    = 3;
432         //SIGSEGV (defined in core.stdc.signal)
433         enum SIGSTOP    = 19;
434         //SIGTERM (defined in core.stdc.signal)
435         enum SIGTSTP    = 20;
436         enum SIGTTIN    = 21;
437         enum SIGTTOU    = 22;
438         enum SIGUSR1    = 10;
439         enum SIGUSR2    = 12;
440         enum SIGURG     = 23;
441     }
442 
443     else
444         static assert(0, "unimplemented");
445 }
446 else version (Darwin)
447 {
448     //SIGABRT (defined in core.stdc.signal)
449     enum SIGALRM    = 14;
450     enum SIGBUS     = 10;
451     enum SIGCHLD    = 20;
452     enum SIGCONT    = 19;
453     //SIGFPE (defined in core.stdc.signal)
454     enum SIGHUP     = 1;
455     //SIGILL (defined in core.stdc.signal)
456     //SIGINT (defined in core.stdc.signal)
457     enum SIGKILL    = 9;
458     enum SIGPIPE    = 13;
459     enum SIGQUIT    = 3;
460     //SIGSEGV (defined in core.stdc.signal)
461     enum SIGSTOP    = 17;
462     //SIGTERM (defined in core.stdc.signal)
463     enum SIGTSTP    = 18;
464     enum SIGTTIN    = 21;
465     enum SIGTTOU    = 22;
466     enum SIGUSR1    = 30;
467     enum SIGUSR2    = 31;
468     enum SIGURG     = 16;
469 }
470 else version (FreeBSD)
471 {
472     //SIGABRT (defined in core.stdc.signal)
473     enum SIGALRM    = 14;
474     enum SIGBUS     = 10;
475     enum SIGCHLD    = 20;
476     enum SIGCONT    = 19;
477     //SIGFPE (defined in core.stdc.signal)
478     enum SIGHUP     = 1;
479     //SIGILL (defined in core.stdc.signal)
480     //SIGINT (defined in core.stdc.signal)
481     enum SIGKILL    = 9;
482     enum SIGPIPE    = 13;
483     enum SIGQUIT    = 3;
484     //SIGSEGV (defined in core.stdc.signal)
485     enum SIGSTOP    = 17;
486     //SIGTERM (defined in core.stdc.signal)
487     enum SIGTSTP    = 18;
488     enum SIGTTIN    = 21;
489     enum SIGTTOU    = 22;
490     enum SIGUSR1    = 30;
491     enum SIGUSR2    = 31;
492     enum SIGURG     = 16;
493 }
494 else version (NetBSD)
495 {
496     //SIGABRT (defined in core.stdc.signal)
497     enum SIGALRM    = 14;
498     enum SIGBUS     = 10;
499     enum SIGCHLD    = 20;
500     enum SIGCONT    = 19;
501     //SIGFPE (defined in core.stdc.signal)
502     enum SIGHUP     = 1;
503     //SIGILL (defined in core.stdc.signal)
504     //SIGINT (defined in core.stdc.signal)
505     enum SIGKILL    = 9;
506     enum SIGPIPE    = 13;
507     enum SIGQUIT    = 3;
508     //SIGSEGV (defined in core.stdc.signal)
509     enum SIGSTOP    = 17;
510     //SIGTERM (defined in core.stdc.signal)
511     enum SIGTSTP    = 18;
512     enum SIGTTIN    = 21;
513     enum SIGTTOU    = 22;
514     enum SIGUSR1    = 30;
515     enum SIGUSR2    = 31;
516     enum SIGURG     = 16;
517 }
518 else version (OpenBSD)
519 {
520     //SIGABRT (defined in core.stdc.signal)
521     enum SIGALRM    = 14;
522     enum SIGBUS     = 10;
523     enum SIGCHLD    = 20;
524     enum SIGCONT    = 19;
525     //SIGFPE (defined in core.stdc.signal)
526     enum SIGHUP     = 1;
527     //SIGILL (defined in core.stdc.signal)
528     //SIGINT (defined in core.stdc.signal)
529     enum SIGKILL    = 9;
530     enum SIGPIPE    = 13;
531     enum SIGQUIT    = 3;
532     //SIGSEGV (defined in core.stdc.signal)
533     enum SIGSTOP    = 17;
534     //SIGTERM (defined in core.stdc.signal)
535     enum SIGTSTP    = 18;
536     enum SIGTTIN    = 21;
537     enum SIGTTOU    = 22;
538     enum SIGUSR1    = 30;
539     enum SIGUSR2    = 31;
540     enum SIGURG     = 16;
541 }
542 else version (DragonFlyBSD)
543 {
544     //SIGABRT (defined in core.stdc.signal)
545     enum SIGALRM    = 14;
546     enum SIGBUS     = 10;
547     enum SIGCHLD    = 20;
548     enum SIGCONT    = 19;
549     //SIGFPE (defined in core.stdc.signal)
550     enum SIGHUP     = 1;
551     //SIGILL (defined in core.stdc.signal)
552     //SIGINT (defined in core.stdc.signal)
553     enum SIGKILL    = 9;
554     enum SIGPIPE    = 13;
555     enum SIGQUIT    = 3;
556     //SIGSEGV (defined in core.stdc.signal)
557     enum SIGSTOP    = 17;
558     //SIGTERM (defined in core.stdc.signal)
559     enum SIGTSTP    = 18;
560     enum SIGTTIN    = 21;
561     enum SIGTTOU    = 22;
562     enum SIGUSR1    = 30;
563     enum SIGUSR2    = 31;
564     enum SIGURG     = 16;
565 }
566 else version (Solaris)
567 {
568     //SIGABRT (defined in core.stdc.signal)
569     enum SIGALRM = 14;
570     enum SIGBUS = 10;
571     enum SIGCHLD = 18;
572     enum SIGCONT = 25;
573     //SIGFPE (defined in core.stdc.signal)
574     enum SIGHUP = 1;
575     //SIGILL (defined in core.stdc.signal)
576     //SIGINT (defined in core.stdc.signal)
577     enum SIGKILL = 9;
578     enum SIGPIPE = 13;
579     enum SIGQUIT = 3;
580     //SIGSEGV (defined in core.stdc.signal)
581     enum SIGSTOP = 23;
582     //SIGTERM (defined in core.stdc.signal)
583     enum SIGTSTP = 24;
584     enum SIGTTIN = 26;
585     enum SIGTTOU = 27;
586     enum SIGUSR1 = 16;
587     enum SIGUSR2 = 17;
588     enum SIGURG = 21;
589 }
590 else
591 {
592     static assert(false, "Unsupported platform");
593 }
594 
595 version (linux)
596 {
597     version (CRuntime_Musl)
598     {
599         struct sigaction_t
600         {
601             union
602             {
603                 sigfn_t     sa_handler;
604                 sigactfn_t  sa_sigaction;
605             }
606             sigset_t        sa_mask;
607             int             sa_flags;
608             void function() sa_restorer;
609         }
610     }
611     else version (CRuntime_Bionic)
612     {
613         version (D_LP64)
614         {
615             struct sigaction_t
616             {
617                 int            sa_flags;
618                 union
619                 {
620                     sigfn_t    sa_handler;
621                     sigactfn_t sa_sigaction;
622                 }
623                 sigset_t        sa_mask;
624                 void function() sa_restorer;
625         }
626         }
627         else
628         {
629             struct sigaction_t
630             {
631                 union
632                 {
633                     sigfn_t    sa_handler;
634                     sigactfn_t sa_sigaction;
635                 }
636                 sigset_t        sa_mask;
637                 int             sa_flags;
638                 void function() sa_restorer;
639             }
640         }
641     }
642     else version (SystemZ)
643     {
644         struct sigaction_t
645         {
646             static if ( true /* __USE_POSIX199309 */ )
647             {
648                 union
649                 {
650                     sigfn_t     sa_handler;
651                     sigactfn_t  sa_sigaction;
652                 }
653             }
654             else
655             {
656                 sigfn_t     sa_handler;
657             }
658             version (CRuntime_Glibc)
659             {
660                 int         __glibc_reserved0;
661                 int         sa_flags;
662             }
663             else
664             {
665                 c_ulong     sa_flags;
666             }
667 
668             void function() sa_restorer;
669 
670             sigset_t        sa_mask;
671         }
672     }
673     else version (HPPA_Any)
674     {
675         struct sigaction_t
676         {
677             static if ( true /* __USE_POSIX199309 */ )
678             {
679                 union
680                 {
681                     sigfn_t     sa_handler;
682                     sigactfn_t  sa_sigaction;
683                 }
684             }
685             else
686             {
687                 sigfn_t     sa_handler;
688             }
689             version (CRuntime_Glibc)
690             {
691                 version (D_LP64)
692                     int     __glibc_reserved0;
693                 int         sa_flags;
694             }
695             else
696             {
697                 c_ulong     sa_flags;
698             }
699             sigset_t        sa_mask;
700         }
701     }
702     else version (MIPS_Any)
703     {
704         struct sigaction_t
705         {
706             int sa_flags;
707 
708             static if ( true /* __USE_POSIX199309 */ )
709             {
710                 union
711                 {
712                     sigfn_t     sa_handler;
713                     sigactfn_t  sa_sigaction;
714                 }
715             }
716             else
717             {
718                 sigfn_t     sa_handler;
719             }
720             sigset_t        sa_mask;
721             void function() sa_restorer;
722 
723             version (CRuntime_Glibc)
724             {
725                 static if ((void*).sizeof < 8)
726                     int[1]  sa_resv;
727             }
728         }
729     }
730     else version (SPARC_Any)
731     {
732         struct sigaction_t
733         {
734             static if ( true /* __USE_POSIX199309 */ )
735             {
736                 union
737                 {
738                     sigfn_t     sa_handler;
739                     sigactfn_t  sa_sigaction;
740                 }
741             }
742             else
743             {
744                 sigfn_t     sa_handler;
745             }
746             version (CRuntime_Glibc)
747             {
748                 sigset_t    sa_mask;
749                 version (D_LP64)
750                     int     __glibc_reserved0;
751                 int         sa_flags;
752                 void function() sa_restorer;
753             }
754             else
755             {
756                 c_ulong     sa_flags;
757                 void function() sa_restorer;
758                 sigset_t    sa_mask;
759             }
760         }
761     }
762     else
763     {
764         struct sigaction_t
765         {
766             static if ( true /* __USE_POSIX199309 */ )
767             {
768                 union
769                 {
770                     sigfn_t     sa_handler;
771                     sigactfn_t  sa_sigaction;
772                 }
773             }
774             else
775             {
776                 sigfn_t     sa_handler;
777             }
778             sigset_t        sa_mask;
779             int             sa_flags;
780 
781             void function() sa_restorer;
782         }
783     }
784 }
785 else version (FreeBSD)
786 {
787     struct sigaction_t
788     {
789         union
790         {
791             sigfn_t     sa_handler;
792             sigactfn_t  sa_sigaction;
793         }
794         int      sa_flags;
795         sigset_t sa_mask;
796     }
797 }
798 else version (NetBSD)
799 {
800     struct sigaction_t
801     {
802         union
803         {
804             sigfn_t     sa_handler;
805             sigactfn_t  sa_sigaction;
806         }
807         sigset_t sa_mask;
808         int      sa_flags;
809     }
810 }
811 else version (OpenBSD)
812 {
813     struct sigaction_t
814     {
815         union
816         {
817             sigfn_t     __sa_handler;
818             alias sa_handler = __sa_handler;
819             sigactfn_t  __sa_sigaction;
820             alias sa_sigaction = __sa_sigaction;
821         }
822         sigset_t sa_mask;
823         int      sa_flags;
824     }
825 }
826 else version (DragonFlyBSD)
827 {
828     struct sigaction_t
829     {
830         union
831         {
832             sigfn_t     sa_handler;
833             sigactfn_t  sa_sigaction;
834         }
835         int      sa_flags;
836         sigset_t sa_mask;
837     }
838 }
839 else version (Solaris)
840 {
841     struct sigaction_t
842     {
843         int sa_flags;
844 
845         union
846         {
847             sigfn_t sa_handler;
848             sigactfn_t sa_sigaction;
849         }
850 
851         sigset_t sa_mask;
852         version (D_LP64) {}
853         else
854             int[2] sa_resv;
855     }
856 }
857 else version (Darwin)
858 {
859     struct sigaction_t
860     {
861         static if ( true /* __USE_POSIX199309 */ )
862         {
863             union
864             {
865                 sigfn_t     sa_handler;
866                 sigactfn_t  sa_sigaction;
867             }
868         }
869         else
870         {
871             sigfn_t     sa_handler;
872         }
873         sigset_t        sa_mask;
874         int             sa_flags;
875     }
876 }
877 else
878 {
879     static assert(false, "Unsupported platform");
880 }
881 
882 //
883 // C Extension (CX)
884 //
885 /*
886 SIG_HOLD
887 
888 sigset_t
889 pid_t   (defined in core.sys.types)
890 
891 SIGABRT (defined in core.stdc.signal)
892 SIGFPE  (defined in core.stdc.signal)
893 SIGILL  (defined in core.stdc.signal)
894 SIGINT  (defined in core.stdc.signal)
895 SIGSEGV (defined in core.stdc.signal)
896 SIGTERM (defined in core.stdc.signal)
897 
898 SA_NOCLDSTOP (CX|XSI)
899 SIG_BLOCK
900 SIG_UNBLOCK
901 SIG_SETMASK
902 
903 struct siginfo_t
904 {
905     int     si_signo;
906     int     si_code;
907 
908     version (XSI)
909     {
910         int     si_errno;
911         pid_t   si_pid;
912         uid_t   si_uid;
913         void*   si_addr;
914         int     si_status;
915         c_long  si_band;
916     }
917     version (RTS)
918     {
919         sigval  si_value;
920     }
921 }
922 
923 SI_USER
924 SI_QUEUE
925 SI_TIMER
926 SI_ASYNCIO
927 SI_MESGQ
928 */
929 
930 nothrow @nogc
931 {
932 
933 version (linux)
934 {
935     enum SIG_HOLD = cast(sigfn_t2) 2;
936 
937     private enum _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof);
938 
939     struct sigset_t
940     {
941         c_ulong[_SIGSET_NWORDS] __val;
942     }
943 
944     enum SA_NOCLDSTOP   = 1; // (CX|XSI)
945 
946     version (MIPS_Any)
947     {
948         enum SIG_BLOCK      = 1;
949         enum SIG_UNBLOCK    = 2;
950         enum SIG_SETMASK    = 3;
951     }
952     else version (SPARC_Any)
953     {
954         enum SIG_BLOCK      = 1;
955         enum SIG_UNBLOCK    = 2;
956         enum SIG_SETMASK    = 4;
957     }
958     else
959     {
960         enum SIG_BLOCK      = 0;
961         enum SIG_UNBLOCK    = 1;
962         enum SIG_SETMASK    = 2;
963     }
964 
965     private enum __SI_MAX_SIZE = 128;
966 
967     static if ( __WORDSIZE == 64 )
968     {
969         private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
970     }
971     else
972     {
973         private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3);
974     }
975 
976     struct siginfo_t
977     {
978         int si_signo;
979         version (MIPS_Any)  // __SI_SWAP_ERRNO_CODE
980         {
981             int si_code;
982             int si_errno;
983         }
984         else
985         {
986             int si_errno;
987             int si_code;
988         }
989 
990         union _sifields_t
991         {
992             int[__SI_PAD_SIZE] _pad;
993 
994             // kill()
995             struct _kill_t
996             {
997                 pid_t si_pid;
998                 uid_t si_uid;
999             } _kill_t _kill;
1000             // POSIX.1b timers.
1001             struct _timer_t
1002             {
1003                 int    si_tid;
1004                 int    si_overrun;
1005                 sigval si_sigval;
1006             } _timer_t _timer;
1007 
1008             // POSIX.1b signals
1009             struct _rt_t
1010             {
1011                 pid_t  si_pid;
1012                 uid_t  si_uid;
1013                 sigval si_sigval;
1014             } _rt_t _rt;
1015 
1016             // SIGCHLD
1017             struct _sigchild_t
1018             {
1019                 pid_t   si_pid;
1020                 uid_t   si_uid;
1021                 int     si_status;
1022                 clock_t si_utime;
1023                 clock_t si_stime;
1024             } _sigchild_t _sigchld;
1025 
1026             // SIGILL, SIGFPE, SIGSEGV, SIGBUS
1027             struct _sigfault_t
1028             {
1029                 void*     si_addr;
1030             } _sigfault_t _sigfault;
1031 
1032             // SIGPOLL
1033             struct _sigpoll_t
1034             {
1035                 c_long   si_band;
1036                 int      si_fd;
1037             } _sigpoll_t _sigpoll;
1038         } _sifields_t _sifields;
1039 
1040     nothrow @nogc:
1041         @property ref pid_t si_pid() return { return _sifields._kill.si_pid; }
1042         @property ref uid_t si_uid() return { return _sifields._kill.si_uid; }
1043         @property ref void* si_addr() return { return _sifields._sigfault.si_addr; }
1044         @property ref int si_status() return { return _sifields._sigchld.si_status; }
1045         @property ref c_long si_band() return { return _sifields._sigpoll.si_band; }
1046         @property ref sigval si_value() return { return _sifields._rt.si_sigval; }
1047     }
1048 
1049     enum
1050     {
1051         SI_ASYNCNL = -60,
1052         SI_TKILL   = -6,
1053         SI_SIGIO,
1054         SI_ASYNCIO,
1055         SI_MESGQ,
1056         SI_TIMER,
1057         SI_QUEUE,
1058         SI_USER,
1059         SI_KERNEL  = 0x80
1060     }
1061 }
1062 else version (Darwin)
1063 {
1064     enum SIG_HOLD = cast(sigfn_t2) 5;
1065 
1066     alias uint sigset_t;
1067 
1068     enum SA_NOCLDSTOP = 8; // (CX|XSI)
1069 
1070     enum SIG_BLOCK   = 1;
1071     enum SIG_UNBLOCK = 2;
1072     enum SIG_SETMASK = 3;
1073 
1074     struct siginfo_t
1075     {
1076         int     si_signo;
1077         int     si_errno;
1078         int     si_code;
1079         pid_t   si_pid;
1080         uid_t   si_uid;
1081         int     si_status;
1082         void*   si_addr;
1083         sigval  si_value;
1084         int     si_band;
1085         uint[7] pad;
1086     }
1087 
1088     enum SI_USER    = 0x10001;
1089     enum SI_QUEUE   = 0x10002;
1090     enum SI_TIMER   = 0x10003;
1091     enum SI_ASYNCIO = 0x10004;
1092     enum SI_MESGQ   = 0x10005;
1093 }
1094 else version (FreeBSD)
1095 {
1096     enum SIG_HOLD = cast(sigfn_t2) 3;
1097 
1098     struct sigset_t
1099     {
1100         uint[4] __bits;
1101     }
1102 
1103     enum SA_NOCLDSTOP = 8;
1104 
1105     enum SIG_BLOCK = 1;
1106     enum SIG_UNBLOCK = 2;
1107     enum SIG_SETMASK = 3;
1108 
1109     struct siginfo_t
1110     {
1111         int si_signo;
1112         int si_errno;
1113         int si_code;
1114         pid_t si_pid;
1115         uid_t si_uid;
1116         int si_status;
1117         void* si_addr;
1118         sigval si_value;
1119         union __reason
1120         {
1121             struct __fault
1122             {
1123                 int _trapno;
1124             }
1125             __fault _fault;
1126             struct __timer
1127             {
1128                 int _timerid;
1129                 int _overrun;
1130             }
1131             __timer _timer;
1132             struct __mesgq
1133             {
1134                 int _mqd;
1135             }
1136             __mesgq _mesgq;
1137             struct __poll
1138             {
1139                 c_long _band;
1140             }
1141             __poll _poll;
1142             struct ___spare___
1143             {
1144                 c_long __spare1__;
1145                 int[7] __spare2__;
1146             }
1147             ___spare___ __spare__;
1148         }
1149         __reason _reason;
1150 
1151         @property ref c_long si_band() return { return _reason._poll._band; }
1152     }
1153 
1154     enum SI_USER    = 0x10001;
1155     enum SI_QUEUE   = 0x10002;
1156     enum SI_TIMER   = 0x10003;
1157     enum SI_ASYNCIO = 0x10004;
1158     enum SI_MESGQ   = 0x10005;
1159 }
1160 else version (NetBSD)
1161 {
1162     enum SIG_HOLD = cast(sigfn_t2) 3;
1163 
1164     struct sigset_t
1165     {
1166         uint[4] __bits;
1167     }
1168 
1169     enum SA_NOCLDSTOP = 8;
1170 
1171     enum SIG_BLOCK = 1;
1172     enum SIG_UNBLOCK = 2;
1173     enum SIG_SETMASK = 3;
1174 
1175     union sigval_t
1176     {
1177         int   sival_int;
1178         void* sival_ptr;
1179     }
1180 
1181     struct _ksiginfo
1182     {
1183         int     _signo;
1184         int     _code;
1185         int     _errno;
1186         version (D_LP64)
1187             int _pad;
1188 
1189         union reason_t
1190         {
1191             struct rt_t
1192             {
1193                 pid_t    _pid;
1194                 uid_t    _uid;
1195                 sigval_t _value;
1196             } rt_t _rt;
1197             struct child_t
1198             {
1199                 pid_t   _pid;
1200                 uid_t   _uid;
1201                 int     _status;
1202                 clock_t _utime;
1203                 clock_t _stime;
1204             } child_t _child;
1205             struct fault_t
1206             {
1207                 void* _addr;
1208                 int   _trap;
1209                 int   _trap2;
1210                 int   _trap3;
1211             } fault_t fault;
1212             struct poll_t
1213             {
1214                 c_long _band;
1215                 int  _fd;
1216             } poll_t _poll;
1217         }
1218         reason_t _reason;
1219     }
1220 
1221     union siginfo_t
1222     {
1223         ubyte[128] si_pad;
1224         _ksiginfo _info;
1225         @property ref c_long si_band() return { return _info._reason._poll._band; }
1226     }
1227 
1228     enum SI_USER    = 0;
1229     enum SI_QUEUE   = -1;
1230     enum SI_TIMER   = -2;
1231     enum SI_ASYNCIO = -3;
1232     enum SI_MESGQ   = -4;
1233 }
1234 else version (OpenBSD)
1235 {
1236     enum SIG_CATCH = cast(sigfn_t2) 2;
1237     enum SIG_HOLD = cast(sigfn_t2) 3;
1238 
1239     alias sigset_t = uint;
1240 
1241     enum SA_NOCLDSTOP = 0x0008;
1242 
1243     enum SIG_BLOCK = 1;
1244     enum SIG_UNBLOCK = 2;
1245     enum SIG_SETMASK = 3;
1246 
1247     private enum SI_MAXSZ = 128;
1248     private enum SI_PAD = (SI_MAXSZ / int.sizeof) - 3;
1249 
1250     struct siginfo_t
1251     {
1252         int si_signo;
1253         int si_errno;
1254         int si_code;
1255         union _data
1256         {
1257             int[SI_PAD] _pad;
1258             struct _proc
1259             {
1260                 pid_t _pid;
1261                 union _pdata
1262                 {
1263                     struct _kill
1264                     {
1265                         uid_t _uid;
1266                         sigval _value;
1267                     }
1268                     struct _cld
1269                     {
1270                         clock_t _utime;
1271                         clock_t _stime;
1272                         int _status;
1273                     }
1274                 }
1275             }
1276             struct _fault
1277             {
1278                 caddr_t _addr;
1279                 int _trapno;
1280             }
1281         }
1282         alias si_pid     = _data._proc._pid;
1283         alias si_status  = _data._proc._pdata._cld._status;
1284         alias si_stime   = _data._proc._pdata._cld._stime;
1285         alias si_utime   = _data._proc._pdata._cld._utime;
1286         alias si_uid     = _data._proc._pdata._kill._uid;
1287         alias si_value   = _data._proc._pdata._kill._value;
1288         alias si_addr    = _data._fault._addr;
1289         alias si_trapno  = _data._fault._trapno;
1290     }
1291 
1292     enum SI_NOINFO = 32767;
1293     enum SI_USER   = 0;
1294     enum SI_LWP    = -1;
1295     enum SI_QUEUE  = -2;
1296     enum SI_TIMER  = -3;
1297 }
1298 else version (DragonFlyBSD)
1299 {
1300     enum SIG_CATCH = cast(sigfn_t2) 2;
1301     enum SIG_HOLD = cast(sigfn_t2) 3;
1302 
1303     struct sigset_t
1304     {
1305         uint[4] __bits;
1306     }
1307 
1308     enum SA_NOCLDSTOP = 8;
1309 
1310     enum SIG_BLOCK = 1;
1311     enum SIG_UNBLOCK = 2;
1312     enum SIG_SETMASK = 3;
1313 
1314     struct siginfo_t
1315     {
1316         int si_signo;
1317         int si_errno;
1318         int si_code;
1319         int si_pid;
1320         uint si_uid;
1321         int si_status;
1322         void* si_addr;
1323         sigval si_value;
1324         c_long si_band;
1325         int[7]   __spare;
1326     }
1327 
1328     enum SI_UNDEFINED = 0x00000;
1329     enum SI_USER      =  0;
1330     enum SI_QUEUE     = -1;
1331     enum SI_TIMER     = -2;
1332     enum SI_ASYNCIO   = -3;
1333     enum SI_MESGQ     = -4;
1334 }
1335 else version (Solaris)
1336 {
1337     enum SIG_HOLD = cast(sigfn_t2)2;
1338 
1339     struct sigset_t
1340     {
1341         uint[4] __bits;
1342     }
1343 
1344     enum SIG_BLOCK = 1;
1345     enum SIG_UNBLOCK = 2;
1346     enum SIG_SETMASK = 3;
1347 
1348     struct siginfo_t
1349     {
1350         int si_signo;
1351         int si_code;
1352         int si_errno;
1353 
1354         version (D_LP64)
1355             int si_pad;
1356 
1357         union ___data
1358         {
1359             version (D_LP64)
1360                 int[(256 / int.sizeof) - 4] si_pad;
1361             else
1362                 int[(128 / int.sizeof) - 3] si_pad;
1363 
1364             struct ___proc
1365             {
1366                 pid_t __pid;
1367 
1368                 union ___pdata
1369                 {
1370                     struct ___kill
1371                     {
1372                         uid_t __uid;
1373                         sigval __value;
1374                     }
1375 
1376                     ___kill __kill;
1377 
1378                     struct ___cld
1379                     {
1380                         clock_t __utime;
1381                         int __status;
1382                         clock_t __stime;
1383                     }
1384 
1385                     ___cld __cld;
1386                 }
1387 
1388                 ___pdata __pdata;
1389                 ctid_t __ctid;
1390                 zoneid_t __zoneid;
1391             }
1392 
1393             ___proc __proc;
1394 
1395             struct ___fault
1396             {
1397                 void* __addr;
1398                 int __trapno;
1399                 caddr_t __pc;
1400             }
1401 
1402             ___fault __fault;
1403 
1404             struct ___file
1405             {
1406                 int __fd;
1407                 c_long __band;
1408             }
1409 
1410             ___file __file;
1411 
1412             struct ___prof
1413             {
1414                 caddr_t __faddr;
1415                 timestruc_t __tstamp;
1416                 short __syscall;
1417                 char __nsysarg = 0;
1418                 char __fault = 0;
1419                 c_long[8] __sysarg;
1420                 int[10] __mstate;
1421             }
1422 
1423             ___prof __prof;
1424 
1425             struct ___rctl
1426             {
1427                 int __entity;
1428             }
1429 
1430             ___rctl __rctl;
1431         }
1432 
1433         ___data __data;
1434     }
1435 
1436     enum SI_NOINFO  = 32767;
1437     enum SI_DTRACE  = 2050;
1438     enum SI_RCTL    = 2049;
1439     enum SI_USER    = 0;
1440     enum SI_LWP     = -1;
1441     enum SI_QUEUE   = -2;
1442     enum SI_TIMER   = -3;
1443     enum SI_ASYNCIO = -4;
1444     enum SI_MESGQ   = -5;
1445 }
1446 else
1447 {
1448     static assert(false, "Unsupported platform");
1449 }
1450 
1451 /*
1452 int kill(pid_t, int);
1453 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1454 int sigaddset(sigset_t*, int);
1455 int sigdelset(sigset_t*, int);
1456 int sigemptyset(sigset_t*);
1457 int sigfillset(sigset_t*);
1458 int sigismember(const scope sigset_t*, int);
1459 int sigpending(sigset_t*);
1460 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1461 int sigsuspend(const scope sigset_t*);
1462 int sigwait(const scope sigset_t*, int*);
1463 */
1464 
1465 version (CRuntime_Glibc)
1466 {
1467     int kill(pid_t, int);
1468     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1469     int sigaddset(sigset_t*, int);
1470     int sigdelset(sigset_t*, int);
1471     int sigemptyset(sigset_t*);
1472     int sigfillset(sigset_t*);
1473     int sigismember(const scope sigset_t*, int);
1474     int sigpending(sigset_t*);
1475     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1476     int sigsuspend(const scope sigset_t*);
1477     int sigwait(const scope sigset_t*, int*);
1478 }
1479 else version (Darwin)
1480 {
1481     int kill(pid_t, int);
1482     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1483     int sigaddset(sigset_t*, int);
1484     int sigdelset(sigset_t*, int);
1485     int sigemptyset(sigset_t*);
1486     int sigfillset(sigset_t*);
1487     int sigismember(const scope sigset_t*, int);
1488     int sigpending(sigset_t*);
1489     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1490     int sigsuspend(const scope sigset_t*);
1491     int sigwait(const scope sigset_t*, int*);
1492 }
1493 else version (FreeBSD)
1494 {
1495     int kill(pid_t, int);
1496     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1497     int sigaddset(sigset_t*, int);
1498     int sigdelset(sigset_t*, int);
1499     int sigemptyset(sigset_t *);
1500     int sigfillset(sigset_t *);
1501     int sigismember(const scope sigset_t*, int);
1502     int sigpending(sigset_t *);
1503     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1504     int sigsuspend(const scope sigset_t*);
1505     int sigwait(const scope sigset_t*, int*);
1506 }
1507 else version (NetBSD)
1508 {
1509     int kill(pid_t, int);
1510     int __sigaction14(int, const scope sigaction_t*, sigaction_t*);
1511     int __sigaddset14(sigset_t*, int);
1512     int __sigdelset14(sigset_t*, int);
1513     int __sigemptyset14(sigset_t *);
1514     int __sigfillset14(sigset_t *);
1515     int __sigismember14(const scope sigset_t*, int);
1516     int __sigpending14(sigset_t *);
1517     int __sigprocmask14(int, const scope sigset_t*, sigset_t*);
1518     int __sigsuspend14(const scope sigset_t*);
1519     int sigwait(const scope sigset_t*, int*);
1520 
1521     alias __sigaction14 sigaction;
1522     alias __sigaddset14 sigaddset;
1523     alias __sigdelset14 sigdelset;
1524     alias __sigemptyset14 sigemptyset;
1525     alias __sigfillset14 sigfillset;
1526     alias __sigismember14 sigismember;
1527     alias __sigpending14 sigpending;
1528     alias __sigprocmask14 sigprocmask;
1529     alias __sigsuspend14 sigsuspend;
1530 }
1531 else version (OpenBSD)
1532 {
1533     int kill(pid_t, int);
1534     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1535     int sigaddset(sigset_t*, int);
1536     int sigdelset(sigset_t*, int);
1537     int sigemptyset(sigset_t *);
1538     int sigfillset(sigset_t *);
1539     int sigismember(const scope sigset_t*, int);
1540     int sigpending(sigset_t *);
1541     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1542     int sigsuspend(const scope sigset_t*);
1543     int sigwait(const scope sigset_t*, int*);
1544 }
1545 else version (DragonFlyBSD)
1546 {
1547     int kill(pid_t, int);
1548     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1549     int sigaddset(sigset_t*, int);
1550     int sigdelset(sigset_t*, int);
1551     int sigemptyset(sigset_t *);
1552     int sigfillset(sigset_t *);
1553     int sigismember(const scope sigset_t*, int);
1554     int sigpending(sigset_t *);
1555     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1556     int sigsuspend(const scope sigset_t*);
1557     int sigwait(const scope sigset_t*, int*);
1558 }
1559 else version (Solaris)
1560 {
1561     int kill(pid_t, int);
1562     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1563     int sigaddset(sigset_t*, int);
1564     int sigdelset(sigset_t*, int);
1565     int sigemptyset(sigset_t*);
1566     int sigfillset(sigset_t*);
1567     int sigismember(const scope sigset_t*, int);
1568     int sigpending(sigset_t*);
1569     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1570     int sigsuspend(const scope sigset_t*);
1571     int sigwait(const scope sigset_t*, int*);
1572 }
1573 else version (CRuntime_Bionic)
1574 {
1575     public import core.sys.posix.time: timer_t;
1576     import core.stdc.string : memset;
1577 
1578     version (X86)
1579         enum int LONG_BIT = 32;
1580     else version (ARM)
1581         enum int LONG_BIT = 32;
1582     else version (AArch64)
1583         enum int LONG_BIT = 64;
1584     else version (X86_64)
1585         enum int LONG_BIT = 64;
1586     else
1587         static assert(false, "Architecture not supported.");
1588 
1589     int kill(pid_t, int);
1590     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1591 
1592     // These functions are defined inline in bionic.
1593     int sigaddset(sigset_t* set, int signum) @system
1594     {
1595         c_ulong* local_set = cast(c_ulong*) set;
1596         signum--;
1597         local_set[signum/LONG_BIT] |= 1UL << (signum%LONG_BIT);
1598         return 0;
1599     }
1600 
1601     int sigdelset(sigset_t* set, int signum) @system
1602     {
1603         c_ulong* local_set = cast(c_ulong*) set;
1604         signum--;
1605         local_set[signum/LONG_BIT] &= ~(1UL << (signum%LONG_BIT));
1606         return 0;
1607     }
1608 
1609     int sigemptyset(sigset_t* set) { memset(set, 0, (*set).sizeof); return 0; }
1610 
1611     int sigfillset(sigset_t* set) { memset(set, ~0, (*set).sizeof); return 0; }
1612 
1613     int sigismember(sigset_t* set, int signum) @system
1614     {
1615         c_ulong* local_set = cast(c_ulong*) set;
1616         signum--;
1617         return cast(int) ((local_set[signum/LONG_BIT] >> (signum%LONG_BIT)) & 1);
1618     }
1619 
1620     int sigpending(sigset_t*);
1621     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1622     int sigsuspend(const scope sigset_t*);
1623     int sigwait(const scope sigset_t*, int*);
1624 }
1625 else version (CRuntime_Musl)
1626 {
1627     int kill(pid_t, int);
1628     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1629     int sigaddset(sigset_t*, int);
1630     int sigdelset(sigset_t*, int);
1631     int sigemptyset(sigset_t*);
1632     int sigfillset(sigset_t*);
1633     int sigismember(const scope sigset_t*, int);
1634     int sigpending(sigset_t*);
1635     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1636     int sigsuspend(const scope sigset_t*);
1637     int sigwait(const scope sigset_t*, int*);
1638 }
1639 else version (CRuntime_UClibc)
1640 {
1641     int kill(pid_t, int);
1642     int sigaction(int, const scope sigaction_t*, sigaction_t*);
1643     int sigaddset(sigset_t*, int);
1644     int sigdelset(sigset_t*, int);
1645     int sigemptyset(sigset_t*);
1646     int sigfillset(sigset_t*);
1647     int sigismember(const scope sigset_t*, int);
1648     int sigpending(sigset_t*);
1649     int sigprocmask(int, const scope sigset_t*, sigset_t*);
1650     int sigsuspend(const scope sigset_t*);
1651     int sigwait(const scope sigset_t*, int*);
1652 }
1653 else
1654 {
1655     static assert(false, "Unsupported platform");
1656 }
1657 }
1658 
1659 //
1660 // XOpen (XSI)
1661 //
1662 /*
1663 SIGPOLL
1664 SIGPROF
1665 SIGSYS
1666 SIGTRAP
1667 SIGVTALRM
1668 SIGXCPU
1669 SIGXFSZ
1670 
1671 SA_ONSTACK
1672 SA_RESETHAND
1673 SA_RESTART
1674 SA_SIGINFO
1675 SA_NOCLDWAIT
1676 SA_NODEFER
1677 
1678 ILL_ILLOPC
1679 ILL_ILLOPN
1680 ILL_ILLADR
1681 ILL_ILLTRP
1682 ILL_PRVOPC
1683 ILL_PRVREG
1684 ILL_COPROC
1685 ILL_BADSTK
1686 
1687 FPE_INTDIV
1688 FPE_INTOVF
1689 FPE_FLTDIV
1690 FPE_FLTOVF
1691 FPE_FLTUND
1692 FPE_FLTRES
1693 FPE_FLTINV
1694 FPE_FLTSUB
1695 
1696 SEGV_MAPERR
1697 SEGV_ACCERR
1698 
1699 BUS_ADRALN
1700 BUS_ADRERR
1701 BUS_OBJERR
1702 
1703 TRAP_BRKPT
1704 TRAP_TRACE
1705 
1706 CLD_EXITED
1707 CLD_KILLED
1708 CLD_DUMPED
1709 CLD_TRAPPED
1710 CLD_STOPPED
1711 CLD_CONTINUED
1712 
1713 POLL_IN
1714 POLL_OUT
1715 POLL_MSG
1716 POLL_ERR
1717 POLL_PRI
1718 POLL_HUP
1719 */
1720 
1721 version (linux)
1722 {
1723     version (X86_Any)
1724     {
1725         enum SIGPOLL        = 29;
1726         enum SIGPROF        = 27;
1727         enum SIGSYS         = 31;
1728         enum SIGTRAP        = 5;
1729         enum SIGVTALRM      = 26;
1730         enum SIGXCPU        = 24;
1731         enum SIGXFSZ        = 25;
1732     }
1733     else version (HPPA_Any)
1734     {
1735         enum SIGPOLL    = 22;
1736         enum SIGPROF    = 21;
1737         enum SIGSYS     = 31;
1738         enum SIGTRAP    = 5;
1739         enum SIGVTALRM  = 20;
1740         enum SIGXCPU    = 12;
1741         enum SIGXFSZ    = 30;
1742     }
1743     else version (MIPS_Any)
1744     {
1745         enum SIGPOLL    = 22;
1746         enum SIGPROF    = 29;
1747         enum SIGSYS     = 12;
1748         enum SIGTRAP    = 5;
1749         enum SIGVTALRM  = 28;
1750         enum SIGXCPU    = 30;
1751         enum SIGXFSZ    = 31;
1752     }
1753     else version (PPC_Any)
1754     {
1755         enum SIGPOLL    = 29;
1756         enum SIGPROF    = 27;
1757         enum SIGSYS     = 31;
1758         enum SIGTRAP    = 5;
1759         enum SIGVTALRM  = 26;
1760         enum SIGXCPU    = 24;
1761         enum SIGXFSZ    = 25;
1762     }
1763     else version (ARM_Any)
1764     {
1765         enum SIGPOLL    = 29;
1766         enum SIGPROF    = 27;
1767         enum SIGSYS     = 31;
1768         enum SIGTRAP    = 5;
1769         enum SIGVTALRM  = 26;
1770         enum SIGXCPU    = 24;
1771         enum SIGXFSZ    = 25;
1772     }
1773     else version (RISCV_Any)
1774     {
1775         enum SIGPOLL    = 29;
1776         enum SIGPROF    = 27;
1777         enum SIGSYS     = 31;
1778         enum SIGTRAP    = 5;
1779         enum SIGVTALRM  = 26;
1780         enum SIGXCPU    = 24;
1781         enum SIGXFSZ    = 25;
1782     }
1783     else version (SPARC_Any)
1784     {
1785         enum SIGPOLL    = 23;
1786         enum SIGPROF    = 27;
1787         enum SIGSYS     = 12;
1788         enum SIGTRAP    = 5;
1789         enum SIGVTALRM  = 26;
1790         enum SIGXCPU    = 24;
1791         enum SIGXFSZ    = 25;
1792     }
1793     else version (IBMZ_Any)
1794     {
1795         enum SIGPOLL    = 29;
1796         enum SIGPROF    = 27;
1797         enum SIGSYS     = 31;
1798         enum SIGTRAP    = 5;
1799         enum SIGVTALRM  = 26;
1800         enum SIGXCPU    = 24;
1801         enum SIGXFSZ    = 25;
1802     }
1803     else version (LoongArch64)
1804     {
1805         enum SIGPOLL    = 29;
1806         enum SIGPROF    = 27;
1807         enum SIGSYS     = 31;
1808         enum SIGTRAP    = 5;
1809         enum SIGVTALRM  = 26;
1810         enum SIGXCPU    = 24;
1811         enum SIGXFSZ    = 25;
1812     }
1813     else version (WebAssembly)
1814     {
1815 	// FIXME: copy paste from X86_Any?
1816     }
1817     else
1818         static assert(0, "unimplemented");
1819 
1820     version (MIPS_Any)
1821     {
1822         enum SA_ONSTACK   = 0x08000000;
1823         enum SA_RESETHAND = 0x80000000;
1824         enum SA_RESTART   = 0x10000000;
1825         enum SA_SIGINFO   = 8;
1826         enum SA_NOCLDWAIT = 0x10000;
1827         enum SA_NODEFER   = 0x40000000;
1828     }
1829     else
1830     {
1831         enum SA_ONSTACK   = 0x08000000;
1832         enum SA_RESETHAND = 0x80000000;
1833         enum SA_RESTART   = 0x10000000;
1834         enum SA_SIGINFO   = 4;
1835         enum SA_NOCLDWAIT = 2;
1836         enum SA_NODEFER   = 0x40000000;
1837     }
1838 
1839     enum SA_NOMASK      = SA_NODEFER;
1840     enum SA_ONESHOT     = SA_RESETHAND;
1841     enum SA_STACK       = SA_ONSTACK;
1842 
1843     enum
1844     {
1845         ILL_ILLOPC = 1,
1846         ILL_ILLOPN,
1847         ILL_ILLADR,
1848         ILL_ILLTRP,
1849         ILL_PRVOPC,
1850         ILL_PRVREG,
1851         ILL_COPROC,
1852         ILL_BADSTK
1853     }
1854 
1855     enum
1856     {
1857         FPE_INTDIV = 1,
1858         FPE_INTOVF,
1859         FPE_FLTDIV,
1860         FPE_FLTOVF,
1861         FPE_FLTUND,
1862         FPE_FLTRES,
1863         FPE_FLTINV,
1864         FPE_FLTSUB
1865     }
1866 
1867     enum
1868     {
1869         SEGV_MAPERR = 1,
1870         SEGV_ACCERR
1871     }
1872 
1873     enum
1874     {
1875         BUS_ADRALN = 1,
1876         BUS_ADRERR,
1877         BUS_OBJERR
1878     }
1879 
1880     enum
1881     {
1882         TRAP_BRKPT = 1,
1883         TRAP_TRACE
1884     }
1885 
1886     enum
1887     {
1888         CLD_EXITED = 1,
1889         CLD_KILLED,
1890         CLD_DUMPED,
1891         CLD_TRAPPED,
1892         CLD_STOPPED,
1893         CLD_CONTINUED
1894     }
1895 
1896     enum
1897     {
1898         POLL_IN = 1,
1899         POLL_OUT,
1900         POLL_MSG,
1901         POLL_ERR,
1902         POLL_PRI,
1903         POLL_HUP
1904     }
1905 }
1906 else version (Darwin)
1907 {
1908     enum SIGPOLL        = 7;
1909     enum SIGPROF        = 27;
1910     enum SIGSYS         = 12;
1911     enum SIGTRAP        = 5;
1912     enum SIGVTALRM      = 26;
1913     enum SIGXCPU        = 24;
1914     enum SIGXFSZ        = 25;
1915 
1916     enum SA_ONSTACK     = 0x0001;
1917     enum SA_RESETHAND   = 0x0004;
1918     enum SA_RESTART     = 0x0002;
1919     enum SA_SIGINFO     = 0x0040;
1920     enum SA_NOCLDWAIT   = 0x0020;
1921     enum SA_NODEFER     = 0x0010;
1922 
1923     enum ILL_ILLOPC = 1;
1924     enum ILL_ILLOPN = 4;
1925     enum ILL_ILLADR = 5;
1926     enum ILL_ILLTRP = 2;
1927     enum ILL_PRVOPC = 3;
1928     enum ILL_PRVREG = 6;
1929     enum ILL_COPROC = 7;
1930     enum ILL_BADSTK = 8;
1931 
1932     enum FPE_INTDIV = 7;
1933     enum FPE_INTOVF = 8;
1934     enum FPE_FLTDIV = 1;
1935     enum FPE_FLTOVF = 2;
1936     enum FPE_FLTUND = 3;
1937     enum FPE_FLTRES = 4;
1938     enum FPE_FLTINV = 5;
1939     enum FPE_FLTSUB = 6;
1940 
1941     enum
1942     {
1943         SEGV_MAPERR = 1,
1944         SEGV_ACCERR
1945     }
1946 
1947     enum
1948     {
1949         BUS_ADRALN = 1,
1950         BUS_ADRERR,
1951         BUS_OBJERR
1952     }
1953 
1954     enum
1955     {
1956         TRAP_BRKPT = 1,
1957         TRAP_TRACE
1958     }
1959 
1960     enum
1961     {
1962         CLD_EXITED = 1,
1963         CLD_KILLED,
1964         CLD_DUMPED,
1965         CLD_TRAPPED,
1966         CLD_STOPPED,
1967         CLD_CONTINUED
1968     }
1969 
1970     enum
1971     {
1972         POLL_IN = 1,
1973         POLL_OUT,
1974         POLL_MSG,
1975         POLL_ERR,
1976         POLL_PRI,
1977         POLL_HUP
1978     }
1979 }
1980 else version (FreeBSD)
1981 {
1982     // No SIGPOLL on *BSD
1983     enum SIGPROF        = 27;
1984     enum SIGSYS         = 12;
1985     enum SIGTRAP        = 5;
1986     enum SIGVTALRM      = 26;
1987     enum SIGXCPU        = 24;
1988     enum SIGXFSZ        = 25;
1989 
1990     enum
1991     {
1992         SA_ONSTACK      = 0x0001,
1993         SA_RESTART      = 0x0002,
1994         SA_RESETHAND    = 0x0004,
1995         SA_NODEFER      = 0x0010,
1996         SA_NOCLDWAIT    = 0x0020,
1997         SA_SIGINFO      = 0x0040,
1998     }
1999 
2000     enum
2001     {
2002         ILL_ILLOPC = 1,
2003         ILL_ILLOPN,
2004         ILL_ILLADR,
2005         ILL_ILLTRP,
2006         ILL_PRVOPC,
2007         ILL_PRVREG,
2008         ILL_COPROC,
2009         ILL_BADSTK,
2010     }
2011 
2012     enum
2013     {
2014         BUS_ADRALN = 1,
2015         BUS_ADRERR,
2016         BUS_OBJERR,
2017     }
2018 
2019     enum
2020     {
2021         SEGV_MAPERR = 1,
2022         SEGV_ACCERR,
2023     }
2024 
2025     enum
2026     {
2027         FPE_INTOVF = 1,
2028         FPE_INTDIV,
2029         FPE_FLTDIV,
2030         FPE_FLTOVF,
2031         FPE_FLTUND,
2032         FPE_FLTRES,
2033         FPE_FLTINV,
2034         FPE_FLTSUB,
2035     }
2036 
2037     enum
2038     {
2039         TRAP_BRKPT = 1,
2040         TRAP_TRACE,
2041     }
2042 
2043     enum
2044     {
2045         CLD_EXITED = 1,
2046         CLD_KILLED,
2047         CLD_DUMPED,
2048         CLD_TRAPPED,
2049         CLD_STOPPED,
2050         CLD_CONTINUED,
2051     }
2052 
2053     enum
2054     {
2055         POLL_IN = 1,
2056         POLL_OUT,
2057         POLL_MSG,
2058         POLL_ERR,
2059         POLL_PRI,
2060         POLL_HUP,
2061     }
2062 }
2063 else version (NetBSD)
2064 {
2065     // No SIGPOLL on *BSD
2066     enum SIGPROF        = 27;
2067     enum SIGSYS         = 12;
2068     enum SIGTRAP        = 5;
2069     enum SIGVTALRM      = 26;
2070     enum SIGXCPU        = 24;
2071     enum SIGXFSZ        = 25;
2072 
2073     enum
2074     {
2075         SA_ONSTACK      = 0x0001,
2076         SA_RESTART      = 0x0002,
2077         SA_RESETHAND    = 0x0004,
2078         SA_NODEFER      = 0x0010,
2079         SA_NOCLDWAIT    = 0x0020,
2080         SA_SIGINFO      = 0x0040,
2081     }
2082 
2083     enum
2084     {
2085         ILL_ILLOPC = 1,
2086         ILL_ILLOPN,
2087         ILL_ILLADR,
2088         ILL_ILLTRP,
2089         ILL_PRVOPC,
2090         ILL_PRVREG,
2091         ILL_COPROC,
2092         ILL_BADSTK,
2093     }
2094 
2095     enum
2096     {
2097         BUS_ADRALN = 1,
2098         BUS_ADRERR,
2099         BUS_OBJERR,
2100     }
2101 
2102     enum
2103     {
2104         SEGV_MAPERR = 1,
2105         SEGV_ACCERR,
2106     }
2107 
2108     enum
2109     {
2110         FPE_INTOVF = 1,
2111         FPE_INTDIV,
2112         FPE_FLTDIV,
2113         FPE_FLTOVF,
2114         FPE_FLTUND,
2115         FPE_FLTRES,
2116         FPE_FLTINV,
2117         FPE_FLTSUB,
2118     }
2119 
2120     enum
2121     {
2122         TRAP_BRKPT = 1,
2123         TRAP_TRACE,
2124     }
2125 
2126     enum
2127     {
2128         CLD_EXITED = 1,
2129         CLD_KILLED,
2130         CLD_DUMPED,
2131         CLD_TRAPPED,
2132         CLD_STOPPED,
2133         CLD_CONTINUED,
2134     }
2135 
2136     enum
2137     {
2138         POLL_IN = 1,
2139         POLL_OUT,
2140         POLL_MSG,
2141         POLL_ERR,
2142         POLL_PRI,
2143         POLL_HUP,
2144     }
2145 }
2146 else version (OpenBSD)
2147 {
2148     // No SIGPOLL on *BSD
2149     enum SIGPROF        = 27;
2150     enum SIGSYS         = 12;
2151     enum SIGTRAP        = 5;
2152     enum SIGVTALRM      = 26;
2153     enum SIGXCPU        = 24;
2154     enum SIGXFSZ        = 25;
2155 
2156     enum
2157     {
2158         SA_ONSTACK      = 0x0001,
2159         SA_RESTART      = 0x0002,
2160         SA_RESETHAND    = 0x0004,
2161         SA_NODEFER      = 0x0010,
2162         SA_NOCLDWAIT    = 0x0020,
2163         SA_SIGINFO      = 0x0040,
2164     }
2165 
2166     enum
2167     {
2168         ILL_ILLOPC = 1,
2169         ILL_ILLOPN,
2170         ILL_ILLADR,
2171         ILL_ILLTRP,
2172         ILL_PRVOPC,
2173         ILL_PRVREG,
2174         ILL_COPROC,
2175         ILL_BADSTK,
2176         NSIGILL = ILL_BADSTK,
2177     }
2178 
2179     enum
2180     {
2181         BUS_ADRALN = 1,
2182         BUS_ADRERR,
2183         BUS_OBJERR,
2184         NSIGBUS = BUS_OBJERR,
2185     }
2186 
2187     enum
2188     {
2189         SEGV_MAPERR = 1,
2190         SEGV_ACCERR,
2191         NSIGSEGV = SEGV_ACCERR,
2192     }
2193 
2194     enum
2195     {
2196         FPE_INTDIV = 1,
2197         FPE_INTOVF,
2198         FPE_FLTDIV,
2199         FPE_FLTOVF,
2200         FPE_FLTUND,
2201         FPE_FLTRES,
2202         FPE_FLTINV,
2203         FPE_FLTSUB,
2204         NSIGFPE = FPE_FLTSUB,
2205     }
2206 
2207     enum
2208     {
2209         TRAP_BRKPT = 1,
2210         TRAP_TRACE,
2211         NSIGTRAP = TRAP_TRACE,
2212     }
2213 
2214     enum
2215     {
2216         CLD_EXITED = 1,
2217         CLD_KILLED,
2218         CLD_DUMPED,
2219         CLD_TRAPPED,
2220         CLD_STOPPED,
2221         CLD_CONTINUED,
2222         NSIGCLD = CLD_CONTINUED,
2223     }
2224 
2225     enum
2226     {
2227         POLL_IN = 1,
2228         POLL_OUT,
2229         POLL_MSG,
2230         POLL_ERR,
2231         POLL_PRI,
2232         POLL_HUP,
2233         NSIGPOLL = POLL_HUP,
2234     }
2235 }
2236 else version (DragonFlyBSD)
2237 {
2238     // No SIGPOLL on *BSD
2239     enum SIGPROF        = 27;
2240     enum SIGSYS         = 12;
2241     enum SIGTRAP        = 5;
2242     enum SIGVTALRM      = 26;
2243     enum SIGXCPU        = 24;
2244     enum SIGXFSZ        = 25;
2245 
2246     enum
2247     {
2248         SA_ONSTACK      = 0x0001,
2249         SA_RESTART      = 0x0002,
2250         SA_RESETHAND    = 0x0004,
2251         SA_NODEFER      = 0x0010,
2252         SA_NOCLDWAIT    = 0x0020,
2253         SA_SIGINFO      = 0x0040,
2254     }
2255 
2256     enum
2257     {
2258         ILL_ILLOPC = 1,
2259         ILL_ILLOPN,
2260         ILL_ILLADR,
2261         ILL_ILLTRP,
2262         ILL_PRVOPC,
2263         ILL_PRVREG,
2264         ILL_COPROC,
2265         ILL_BADSTK,
2266     }
2267 
2268     enum
2269     {
2270         BUS_ADRALN = 1,
2271         BUS_ADRERR,
2272         BUS_OBJERR,
2273     }
2274 
2275     enum
2276     {
2277         SEGV_MAPERR = 1,
2278         SEGV_ACCERR,
2279     }
2280 
2281     enum
2282     {
2283         FPE_INTOVF = 1,
2284         FPE_INTDIV,
2285         FPE_FLTDIV,
2286         FPE_FLTOVF,
2287         FPE_FLTUND,
2288         FPE_FLTRES,
2289         FPE_FLTINV,
2290         FPE_FLTSUB,
2291     }
2292 
2293     enum
2294     {
2295         TRAP_BRKPT = 1,
2296         TRAP_TRACE,
2297     }
2298 
2299     enum
2300     {
2301         CLD_EXITED = 1,
2302         CLD_KILLED,
2303         CLD_DUMPED,
2304         CLD_TRAPPED,
2305         CLD_STOPPED,
2306         CLD_CONTINUED,
2307     }
2308 
2309     enum
2310     {
2311         POLL_IN = 1,
2312         POLL_OUT,
2313         POLL_MSG,
2314         POLL_ERR,
2315         POLL_PRI,
2316         POLL_HUP,
2317     }
2318 }
2319 else version (Solaris)
2320 {
2321     enum SIGPOLL = 22;
2322     enum SIGIO = SIGPOLL;
2323     enum SIGPROF = 29;
2324     enum SIGSYS = 12;
2325     enum SIGTRAP = 5;
2326     enum SIGVTALRM = 28;
2327     enum SIGXCPU = 30;
2328     enum SIGXFSZ = 31;
2329 
2330     enum
2331     {
2332         SA_ONSTACK = 0x00001,
2333         SA_RESTART = 0x00004,
2334         SA_RESETHAND = 0x00002,
2335         SA_NODEFER = 0x00010,
2336         SA_NOCLDWAIT = 0x10000,
2337         SA_SIGINFO = 0x00008,
2338     }
2339 
2340     enum
2341     {
2342         ILL_ILLOPC = 1,
2343         ILL_ILLOPN,
2344         ILL_ILLADR,
2345         ILL_ILLTRP,
2346         ILL_PRVOPC,
2347         ILL_PRVREG,
2348         ILL_COPROC,
2349         ILL_BADSTK,
2350     }
2351 
2352     enum
2353     {
2354         BUS_ADRALN = 1,
2355         BUS_ADRERR,
2356         BUS_OBJERR,
2357     }
2358 
2359     enum
2360     {
2361         SEGV_MAPERR = 1,
2362         SEGV_ACCERR,
2363     }
2364 
2365     enum
2366     {
2367         FPE_INTDIV = 1,
2368         FPE_INTOVF,
2369         FPE_FLTDIV,
2370         FPE_FLTOVF,
2371         FPE_FLTUND,
2372         FPE_FLTRES,
2373         FPE_FLTINV,
2374         FPE_FLTSUB,
2375         FPE_FLTDEN,
2376     }
2377 
2378     enum
2379     {
2380         TRAP_BRKPT = 1,
2381         TRAP_TRACE,
2382         TRAP_RWATCH,
2383         TRAP_WWATCH,
2384         TRAP_XWATCH,
2385         TRAP_DTRACE,
2386     }
2387 
2388     enum
2389     {
2390         CLD_EXITED = 1,
2391         CLD_KILLED,
2392         CLD_DUMPED,
2393         CLD_TRAPPED,
2394         CLD_STOPPED,
2395         CLD_CONTINUED,
2396     }
2397 
2398     enum
2399     {
2400         POLL_IN = 1,
2401         POLL_OUT,
2402         POLL_MSG,
2403         POLL_ERR,
2404         POLL_PRI,
2405         POLL_HUP,
2406     }
2407 }
2408 else
2409 {
2410     static assert(false, "Unsupported platform");
2411 }
2412 
2413 /*
2414 SS_ONSTACK
2415 SS_DISABLE
2416 MINSIGSTKSZ
2417 SIGSTKSZ
2418 
2419 ucontext_t // from ucontext
2420 mcontext_t // from ucontext
2421 
2422 struct stack_t
2423 {
2424     void*   ss_sp;
2425     size_t  ss_size;
2426     int     ss_flags;
2427 }
2428 
2429 struct sigstack
2430 {
2431     int   ss_onstack;
2432     void* ss_sp;
2433 }
2434 
2435 sigfn_t bsd_signal(int sig, sigfn_t func);
2436 sigfn_t sigset(int sig, sigfn_t func);
2437 
2438 int killpg(pid_t, int);
2439 int sigaltstack(const scope stack_t*, stack_t*);
2440 int sighold(int);
2441 int sigignore(int);
2442 int siginterrupt(int, int);
2443 int sigpause(int);
2444 int sigrelse(int);
2445 */
2446 
2447 version (CRuntime_Glibc)
2448 {
2449     enum SS_ONSTACK     = 1;
2450     enum SS_DISABLE     = 2;
2451     enum MINSIGSTKSZ    = 2048;
2452     enum SIGSTKSZ       = 8192;
2453 
2454     //ucontext_t (defined in core.sys.posix.ucontext)
2455     //mcontext_t (defined in core.sys.posix.ucontext)
2456 
2457     version (MIPS_Any)
2458     {
2459         struct stack_t
2460         {
2461             void*   ss_sp;
2462             size_t  ss_size;
2463             int     ss_flags;
2464         }
2465     }
2466     else
2467     {
2468         struct stack_t
2469         {
2470             void*   ss_sp;
2471             int     ss_flags;
2472             size_t  ss_size;
2473         }
2474     }
2475 
2476     struct sigstack
2477     {
2478         void*   ss_sp;
2479         int     ss_onstack;
2480     }
2481 
2482     sigfn_t bsd_signal(int sig, sigfn_t func);
2483     sigfn_t sigset(int sig, sigfn_t func);
2484 
2485   nothrow:
2486   @nogc:
2487     sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2488     sigfn_t2 sigset(int sig, sigfn_t2 func);
2489 
2490     int killpg(pid_t, int);
2491     int sigaltstack(const scope stack_t*, stack_t*);
2492     int sighold(int);
2493     int sigignore(int);
2494     int siginterrupt(int, int);
2495     int sigpause(int);
2496     int sigrelse(int);
2497 }
2498 else version (Darwin)
2499 {
2500     enum SS_ONSTACK     = 0x0001;
2501     enum SS_DISABLE     = 0x0004;
2502     enum MINSIGSTKSZ    = 32768;
2503     enum SIGSTKSZ       = 131072;
2504 
2505     //ucontext_t (defined in core.sys.posix.ucontext)
2506     //mcontext_t (defined in core.sys.posix.ucontext)
2507 
2508     struct stack_t
2509     {
2510         void*   ss_sp;
2511         size_t  ss_size;
2512         int     ss_flags;
2513     }
2514 
2515     struct sigstack
2516     {
2517         void*   ss_sp;
2518         int     ss_onstack;
2519     }
2520 
2521     sigfn_t bsd_signal(int sig, sigfn_t func);
2522     sigfn_t sigset(int sig, sigfn_t func);
2523 
2524   nothrow:
2525   @nogc:
2526     sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2527     sigfn_t2 sigset(int sig, sigfn_t2 func);
2528 
2529     int killpg(pid_t, int);
2530     int sigaltstack(const scope stack_t*, stack_t*);
2531     int sighold(int);
2532     int sigignore(int);
2533     int siginterrupt(int, int);
2534     int sigpause(int);
2535     int sigrelse(int);
2536 }
2537 else version (FreeBSD)
2538 {
2539     enum
2540     {
2541         SS_ONSTACK = 0x0001,
2542         SS_DISABLE = 0x0004,
2543     }
2544 
2545     enum MINSIGSTKSZ = 512 * 4;
2546     enum SIGSTKSZ    = (MINSIGSTKSZ + 32768);
2547 
2548     //ucontext_t (defined in core.sys.posix.ucontext)
2549     //mcontext_t (defined in core.sys.posix.ucontext)
2550 
2551     struct stack_t
2552     {
2553         void*   ss_sp;
2554         size_t  ss_size;
2555         int     ss_flags;
2556     }
2557 
2558     struct sigstack
2559     {
2560         void*   ss_sp;
2561         int     ss_onstack;
2562     }
2563 
2564     //sigfn_t bsd_signal(int sig, sigfn_t func);
2565     sigfn_t sigset(int sig, sigfn_t func);
2566 
2567   nothrow:
2568   @nogc:
2569     //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2570     sigfn_t2 sigset(int sig, sigfn_t2 func);
2571 
2572     int killpg(pid_t, int);
2573     int sigaltstack(const scope stack_t*, stack_t*);
2574     int sighold(int);
2575     int sigignore(int);
2576     int siginterrupt(int, int);
2577     int sigpause(int);
2578     int sigrelse(int);
2579 }
2580 else version (NetBSD)
2581 {
2582     enum
2583     {
2584         SS_ONSTACK = 0x0001,
2585         SS_DISABLE = 0x0004,
2586     }
2587 
2588     enum MINSIGSTKSZ = 8192;
2589     enum SIGSTKSZ    = (MINSIGSTKSZ + 32768);
2590 
2591     //ucontext_t (defined in core.sys.posix.ucontext)
2592     //mcontext_t (defined in core.sys.posix.ucontext)
2593 
2594     struct stack_t
2595     {
2596         void*   ss_sp;
2597         size_t  ss_size;
2598         int     ss_flags;
2599     }
2600 
2601     struct sigstack
2602     {
2603         void*   ss_sp;
2604         int     ss_onstack;
2605     }
2606 
2607     //sigfn_t bsd_signal(int sig, sigfn_t func);
2608     sigfn_t sigset(int sig, sigfn_t func);
2609 
2610   nothrow:
2611   @nogc:
2612     //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2613     sigfn_t2 sigset(int sig, sigfn_t2 func);
2614 
2615     int killpg(pid_t, int);
2616     int sigaltstack(const scope stack_t*, stack_t*);
2617     int sighold(int);
2618     int sigignore(int);
2619     int siginterrupt(int, int);
2620     int sigpause(int);
2621     int sigrelse(int);
2622 }
2623 else version (OpenBSD)
2624 {
2625     enum
2626     {
2627         SS_ONSTACK = 0x0001,
2628         SS_DISABLE = 0x0004,
2629     }
2630 
2631     enum MINSIGSTKSZ = 8192;
2632     enum SIGSTKSZ    = (MINSIGSTKSZ + 32768);
2633 
2634     //ucontext_t (defined in core.sys.posix.ucontext)
2635     //mcontext_t (defined in core.sys.posix.ucontext)
2636 
2637     struct stack_t
2638     {
2639         void*   ss_sp;
2640         size_t  ss_size;
2641         int     ss_flags;
2642     }
2643 
2644   nothrow:
2645   @nogc:
2646     int killpg(pid_t, int);
2647     int sigaltstack(const scope stack_t*, stack_t*);
2648     int siginterrupt(int, int);
2649     int sigpause(int);
2650 }
2651 else version (DragonFlyBSD)
2652 {
2653     enum
2654     {
2655         SS_ONSTACK = 0x0001,
2656         SS_DISABLE = 0x0004,
2657     }
2658 
2659     enum MINSIGSTKSZ = 8192;
2660     enum SIGSTKSZ    = (MINSIGSTKSZ + 32768);
2661 
2662     //ucontext_t (defined in core.sys.posix.ucontext)
2663     //mcontext_t (defined in core.sys.posix.ucontext)
2664 
2665     struct stack_t
2666     {
2667         void*   ss_sp;
2668         size_t  ss_size;
2669         int     ss_flags;
2670     }
2671 
2672     struct sigstack
2673     {
2674         void*   ss_sp;
2675         int     ss_onstack;
2676     }
2677 
2678     //sigfn_t bsd_signal(int sig, sigfn_t func);
2679     sigfn_t sigset(int sig, sigfn_t func);
2680 
2681   nothrow:
2682   @nogc:
2683     //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2684     sigfn_t2 sigset(int sig, sigfn_t2 func);
2685 
2686     int killpg(pid_t, int);
2687     int sigaltstack(const scope stack_t*, stack_t*);
2688     int sighold(int);
2689     int sigignore(int);
2690     int siginterrupt(int, int);
2691     int sigpause(int);
2692     int sigrelse(int);
2693 }
2694 else version (Solaris)
2695 {
2696     enum
2697     {
2698         SS_ONSTACK = 0x0001,
2699         SS_DISABLE = 0x0002,
2700     }
2701 
2702     enum MINSIGSTKSZ = 2048;
2703     enum SIGSTKSZ = 8192;
2704 
2705     struct stack_t
2706     {
2707         void* ss_sp;
2708         size_t ss_size;
2709         int ss_flags;
2710     }
2711 
2712     struct sigstack
2713     {
2714         void* ss_sp;
2715         int ss_onstack;
2716     }
2717 
2718     sigfn_t sigset(int sig, sigfn_t func);
2719 
2720   nothrow:
2721   @nogc:
2722     sigfn_t2 sigset(int sig, sigfn_t2 func);
2723 
2724     int killpg(pid_t, int);
2725     int sigaltstack(const scope stack_t*, stack_t*);
2726     int sighold(int);
2727     int sigignore(int);
2728     int siginterrupt(int, int);
2729     int sigpause(int);
2730     int sigrelse(int);
2731 }
2732 else version (CRuntime_Bionic)
2733 {
2734     enum SS_ONSTACK     = 1;
2735     enum SS_DISABLE     = 2;
2736     enum MINSIGSTKSZ    = 2048;
2737     enum SIGSTKSZ       = 8192;
2738 
2739     struct stack_t
2740     {
2741         void*   ss_sp;
2742         int     ss_flags;
2743         size_t  ss_size;
2744     }
2745 
2746     sigfn_t bsd_signal(int, sigfn_t);
2747 
2748   nothrow:
2749   @nogc:
2750     sigfn_t2 bsd_signal(int, sigfn_t2);
2751 
2752     int killpg(int, int);
2753     int sigaltstack(const scope stack_t*, stack_t*);
2754     int siginterrupt(int, int);
2755 }
2756 else version (CRuntime_Musl)
2757 {
2758     enum SS_ONSTACK = 1;
2759     enum SS_DISABLE = 2;
2760 
2761     version (ARM)
2762     {
2763         enum MINSIGSTKSZ = 2048;
2764         enum SIGSTKSZ    = 8192;
2765     }
2766     else version (AArch64)
2767     {
2768         enum MINSIGSTKSZ = 6144;
2769         enum SIGSTKSZ    = 12288;
2770     }
2771     else version (IBMZ_Any)
2772     {
2773         enum MINSIGSTKSZ = 4096;
2774         enum SIGSTKSZ    = 10240;
2775     }
2776     else version (MIPS_Any)
2777     {
2778         enum MINSIGSTKSZ = 2048;
2779         enum SIGSTKSZ    = 8192;
2780     }
2781     else version (PPC_Any)
2782     {
2783         enum MINSIGSTKSZ = 4096;
2784         enum SIGSTKSZ    = 10240;
2785     }
2786     else version (X86_Any)
2787     {
2788         enum MINSIGSTKSZ = 2048;
2789         enum SIGSTKSZ    = 8192;
2790     }
2791     else version (WebAssembly)
2792     {
2793 	// FIXME: copy paste from X86_Any?
2794     }
2795     else
2796         static assert(0, "unimplemented");
2797 
2798     //ucontext_t (defined in core.sys.posix.ucontext)
2799     //mcontext_t (defined in core.sys.posix.ucontext)
2800 
2801     version (MIPS_Any)
2802     {
2803         struct stack_t
2804         {
2805             void*  ss_sp;
2806             size_t ss_size;
2807             int    ss_flags;
2808         }
2809     }
2810     else
2811     {
2812         struct stack_t
2813         {
2814             void*  ss_sp;
2815             int    ss_flags;
2816             size_t ss_size;
2817         }
2818     }
2819 
2820     sigfn_t bsd_signal(int sig, sigfn_t func);
2821     sigfn_t sigset(int sig, sigfn_t func);
2822 
2823   nothrow:
2824   @nogc:
2825     sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2826     sigfn_t2 sigset(int sig, sigfn_t2 func);
2827 
2828     int killpg(pid_t, int);
2829     int sigaltstack(const scope stack_t*, stack_t*);
2830     int sighold(int);
2831     int sigignore(int);
2832     int siginterrupt(int, int);
2833     int sigpause(int);
2834     int sigrelse(int);
2835 }
2836 else version (CRuntime_UClibc)
2837 {
2838     enum SS_ONSTACK     = 1;
2839     enum SS_DISABLE     = 2;
2840     enum MINSIGSTKSZ    = 2048;
2841     enum SIGSTKSZ       = 8192;
2842 
2843     version (MIPS_Any)
2844     {
2845         struct stack_t
2846         {
2847             void *ss_sp;
2848             size_t ss_size;
2849             int ss_flags;
2850         }
2851     }
2852     else
2853     {
2854         struct stack_t
2855         {
2856             void*   ss_sp;
2857             int     ss_flags;
2858             size_t  ss_size;
2859         }
2860      }
2861 
2862     struct sigstack
2863     {
2864         void*   ss_sp;
2865         int     ss_onstack;
2866     }
2867 
2868     sigfn_t sigset(int sig, sigfn_t func);
2869 
2870   nothrow:
2871   @nogc:
2872     sigfn_t2 sigset(int sig, sigfn_t2 func);
2873 
2874     int killpg(pid_t, int);
2875     int sigaltstack(const scope stack_t*, stack_t*);
2876     int sighold(int);
2877     int sigignore(int);
2878     int siginterrupt(int, int);
2879     int sigpause(int);
2880     int sigrelse(int);
2881 }
2882 else
2883 {
2884     static assert(false, "Unsupported platform");
2885 }
2886 
2887 //
2888 // Realtime Signals (RTS)
2889 //
2890 /*
2891 struct sigevent
2892 {
2893     int             sigev_notify;
2894     int             sigev_signo;
2895     sigval          sigev_value;
2896     void(*)(sigval) sigev_notify_function;
2897     pthread_attr_t* sigev_notify_attributes;
2898 }
2899 */
2900 
2901 nothrow:
2902 @nogc:
2903 
2904 version (linux)
2905 {
2906     private enum __SIGEV_MAX_SIZE = 64;
2907 
2908     static if ( __WORDSIZE == 64 )
2909     {
2910         private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
2911     }
2912     else
2913     {
2914         private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3);
2915     }
2916 
2917     struct sigevent
2918     {
2919         sigval      sigev_value;
2920         int         sigev_signo;
2921         int         sigev_notify;
2922 
2923         union
2924         {
2925             int[__SIGEV_PAD_SIZE] _pad;
2926             pid_t                 _tid;
2927 
2928             struct
2929             {
2930                 void function(sigval) sigev_notify_function;
2931                 void*                 sigev_notify_attributes;
2932             }
2933         }
2934     }
2935 }
2936 else version (FreeBSD)
2937 {
2938     struct sigevent
2939     {
2940         int             sigev_notify;
2941         int             sigev_signo;
2942         sigval          sigev_value;
2943         union
2944         {
2945             lwpid_t _threadid;
2946             struct
2947             {
2948                 void function(sigval) sigev_notify_function;
2949                 void* sigev_notify_attributes;
2950             }
2951             c_long[8] __spare__;
2952         }
2953     }
2954 }
2955 else version (NetBSD)
2956 {
2957     struct sigevent
2958     {
2959         int             sigev_notify;
2960         int             sigev_signo;
2961         sigval          sigev_value;
2962         void function(sigval) sigev_notify_function;
2963         void /* pthread_attr_t */*sigev_notify_attributes;
2964     }
2965 }
2966 else version (OpenBSD)
2967 {
2968     // OpenBSD does not implement sigevent.
2969     alias sigevent = void;
2970 }
2971 else version (DragonFlyBSD)
2972 {
2973     union  _sigev_un_t
2974     {
2975         int                       sigev_signo;
2976         int                       sigev_notify_kqueue;
2977         void /*pthread_attr_t*/ * sigev_notify_attributes;
2978     }
2979     union _sigval_t
2980     {
2981         int                       sival_int;
2982         void                    * sival_ptr;
2983         int                       sigval_int;
2984         void                    * sigval_ptr;
2985     }
2986     struct sigevent
2987     {
2988         int                       sigev_notify;
2989         _sigev_un_t               sigev_un;
2990         _sigval_t                 sigev_value;
2991         void function(_sigval_t)  sigev_notify_function;
2992     }
2993 }
2994 else version (Darwin)
2995 {
2996     struct sigevent
2997     {
2998         int sigev_notify;
2999         int sigev_signo;
3000         sigval sigev_value;
3001         void function(sigval) sigev_notify_function;
3002         pthread_attr_t* sigev_notify_attributes;
3003     }
3004 }
3005 else version (Solaris)
3006 {
3007     struct sigevent
3008     {
3009         int sigev_notify;
3010         int sigev_signo;
3011         sigval sigev_value;
3012         void function(sigval) sigev_notify_function;
3013         pthread_attr_t* sigev_notify_attributes;
3014         int __sigev_pad2;
3015     }
3016 }
3017 else
3018 {
3019     static assert(false, "Unsupported platform");
3020 }
3021 
3022 /*
3023 int sigqueue(pid_t, int, const sigval);
3024 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3025 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3026 */
3027 
3028 nothrow:
3029 @nogc:
3030 
3031 version (CRuntime_Glibc)
3032 {
3033     int sigqueue(pid_t, int, const sigval);
3034     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3035     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3036 }
3037 else version (FreeBSD)
3038 {
3039     int sigqueue(pid_t, int, const sigval);
3040     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3041     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3042 }
3043 else version (NetBSD)
3044 {
3045     int sigqueue(pid_t, int, const sigval);
3046     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3047     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3048 }
3049 else version (OpenBSD)
3050 {
3051 }
3052 else version (DragonFlyBSD)
3053 {
3054     int sigqueue(pid_t, int, const sigval);
3055     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3056     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3057 }
3058 else version (Darwin)
3059 {
3060 }
3061 else version (Solaris)
3062 {
3063     int sigqueue(pid_t, int, const sigval);
3064     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3065     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3066 }
3067 else version (CRuntime_Bionic)
3068 {
3069 }
3070 else version (CRuntime_Musl)
3071 {
3072     int sigqueue(pid_t, int, const sigval);
3073     pragma(mangle, muslRedirTime64Mangle!("sigtimedwait", "__sigtimedwait_time64"))
3074     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3075     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3076 }
3077 else version (CRuntime_UClibc)
3078 {
3079     int sigqueue(pid_t, int, const sigval);
3080     int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3081     int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3082 }
3083 else
3084 {
3085     static assert(false, "Unsupported platform");
3086 }
3087 
3088 //
3089 // Threads (THR)
3090 //
3091 /*
3092 int pthread_kill(pthread_t, int);
3093 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3094 */
3095 
3096 version (CRuntime_Glibc)
3097 {
3098     int pthread_kill(pthread_t, int);
3099     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3100 }
3101 else version (Darwin)
3102 {
3103     int pthread_kill(pthread_t, int);
3104     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3105 }
3106 else version (FreeBSD)
3107 {
3108     int pthread_kill(pthread_t, int);
3109     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3110 }
3111 else version (NetBSD)
3112 {
3113     int pthread_kill(pthread_t, int);
3114     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3115 }
3116 else version (OpenBSD)
3117 {
3118     int pthread_kill(pthread_t, int);
3119     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3120 }
3121 else version (DragonFlyBSD)
3122 {
3123     int pthread_kill(pthread_t, int);
3124     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3125 }
3126 else version (Solaris)
3127 {
3128     int pthread_kill(pthread_t, int);
3129     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3130 }
3131 else version (CRuntime_Bionic)
3132 {
3133     int pthread_kill(pthread_t, int);
3134     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3135 }
3136 else version (CRuntime_Musl)
3137 {
3138     int pthread_kill(pthread_t, int);
3139     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3140 }
3141 else version (CRuntime_UClibc)
3142 {
3143     int pthread_kill(pthread_t, int);
3144     int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3145     int pthread_sigqueue(pthread_t, int, sigval);
3146 }
3147 else
3148 {
3149     static assert(false, "Unsupported platform");
3150 }
The OpenD Programming Language
