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

Page generated by adrdox