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