import/stdc/posix/signal.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Public Domain
   5  * License:   Public Domain
   6  * Authors:   Sean Kelly
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9 module stdc.posix.signal;
  10
  11 private import stdc.posix.config;
  12 public import stdc.signal;
  13 public import stdc.stddef;          // for size_t
  14 public import stdc.posix.sys.types; // for pid_t
  15 //public import stdc.posix.time;      // for timespec, now defined here
  16
  17 extern (C):
  18
  19 private alias void function(int) sigfn_t;
  20 private alias void function(int, siginfo_t*, void*) sigactfn_t;
  21
  22 //
  23 // Required
  24 //
  25 /*
  26 SIG_DFL (defined in stdc.signal)
  27 SIG_ERR (defined in stdc.signal)
  28 SIG_IGN (defined in stdc.signal)
  29
  30 sig_atomic_t (defined in stdc.signal)
  31
  32 SIGEV_NONE
  33 SIGEV_SIGNAL
  34 SIGEV_THREAD
  35
  36 union sigval
  37 {
  38     int   sival_int;
  39     void* sival_ptr;
  40 }
  41
  42 SIGRTMIN
  43 SIGRTMAX
  44
  45 SIGABRT (defined in stdc.signal)
  46 SIGALRM
  47 SIGBUS
  48 SIGCHLD
  49 SIGCONT
  50 SIGFPE (defined in stdc.signal)
  51 SIGHUP
  52 SIGILL (defined in stdc.signal)
  53 SIGINT (defined in stdc.signal)
  54 SIGKILL
  55 SIGPIPE
  56 SIGQUIT
  57 SIGSEGV (defined in stdc.signal)
  58 SIGSTOP
  59 SIGTERM (defined in stdc.signal)
  60 SIGTSTP
  61 SIGTTIN
  62 SIGTTOU
  63 SIGUSR1
  64 SIGUSR2
  65 SIGURG
  66
  67 struct sigaction_t
  68 {
  69     sigfn_t     sa_handler;
  70     sigset_t    sa_mask;
  71     sigactfn_t  sa_sigaction;
  72 }
  73
  74 sigfn_t signal(int sig, sigfn_t func); (defined in stdc.signal)
  75 int raise(int sig);                    (defined in stdc.signal)
  76 */
  77
  78 //SIG_DFL (defined in stdc.signal)
  79 //SIG_ERR (defined in stdc.signal)
  80 //SIG_IGN (defined in stdc.signal)
  81
  82 //sig_atomic_t (defined in stdc.signal)
  83
  84 enum
  85 {
  86   SIGEV_SIGNAL,
  87   SIGEV_NONE,
  88   SIGEV_THREAD
  89 }
  90
  91 union sigval
  92 {
  93     int     sival_int;
  94     void*   sival_ptr;
  95 }
  96
  97 private extern (C) int __libc_current_sigrtmin();
  98 private extern (C) int __libc_current_sigrtmax();
  99
 100 alias __libc_current_sigrtmin SIGRTMIN;
 101 alias __libc_current_sigrtmax SIGRTMAX;
 102
 103 version( linux )
 104 {
 105     //SIGABRT (defined in stdc.signal)
 106     const SIGALRM   = 14;
 107     const SIGBUS    = 7;
 108     const SIGCHLD   = 17;
 109     const SIGCONT   = 18;
 110     //SIGFPE (defined in stdc.signal)
 111     const SIGHUP    = 1;
 112     //SIGILL (defined in stdc.signal)
 113     //SIGINT (defined in stdc.signal)
 114     const SIGKILL   = 9;
 115     const SIGPIPE   = 13;
 116     const SIGQUIT   = 3;
 117     //SIGSEGV (defined in stdc.signal)
 118     const SIGSTOP   = 19;
 119     //SIGTERM (defined in stdc.signal)
 120     const SIGTSTP   = 20;
 121     const SIGTTIN   = 21;
 122     const SIGTTOU   = 22;
 123     const SIGUSR1   = 10;
 124     const SIGUSR2   = 12;
 125     const SIGURG    = 23;
 126 }
 127 else version( darwin )
 128 {
 129     //SIGABRT (defined in stdc.signal)
 130     const SIGALRM   = 14;
 131     const SIGBUS    = 10;
 132     const SIGCHLD   = 20;
 133     const SIGCONT   = 19;
 134     //SIGFPE (defined in stdc.signal)
 135     const SIGHUP    = 1;
 136     //SIGILL (defined in stdc.signal)
 137     //SIGINT (defined in stdc.signal)
 138     const SIGKILL   = 9;
 139     const SIGPIPE   = 13;
 140     const SIGQUIT   = 3;
 141     //SIGSEGV (defined in stdc.signal)
 142     const SIGSTOP   = 17;
 143     //SIGTERM (defined in stdc.signal)
 144     const SIGTSTP   = 18;
 145     const SIGTTIN   = 21;
 146     const SIGTTOU   = 22;
 147     const SIGUSR1   = 30;
 148     const SIGUSR2   = 31;
 149     const SIGURG    = 16;
 150 }
 151 else version( freebsd )
 152 {
 153         //SIGABRT (defined in stdc.signal)
 154     const SIGALRM   = 14;
 155     const SIGBUS    = 10;
 156     const SIGCHLD   = 20;
 157     const SIGCONT   = 19;
 158     //SIGFPE (defined in stdc.signal)
 159     const SIGHUP    = 1;
 160     //SIGILL (defined in stdc.signal)
 161     //SIGINT (defined in stdc.signal)
 162     const SIGKILL   = 9;
 163     const SIGPIPE   = 13;
 164     const SIGQUIT   = 3;
 165     //SIGSEGV (defined in stdc.signal)
 166     const SIGSTOP   = 17;
 167     //SIGTERM (defined in stdc.signal)
 168     const SIGTSTP   = 18;
 169     const SIGTTIN   = 21;
 170     const SIGTTOU   = 22;
 171     const SIGUSR1   = 30;
 172     const SIGUSR2   = 31;
 173     const SIGURG    = 16;
 174 }
 175
 176 struct sigaction_t
 177 {
 178     static if( true /* __USE_POSIX199309 */ )
 179     {
 180         union
 181         {
 182             sigfn_t     sa_handler;
 183             sigactfn_t  sa_sigaction;
 184         }
 185     }
 186     else
 187     {
 188         sigfn_t     sa_handler;
 189     }
 190     sigset_t        sa_mask;
 191     int             sa_flags;
 192
 193     version( darwin ) {} else {
 194     void function() sa_restorer;
 195     }
 196 }
 197
 198 //
 199 // C Extension (CX)
 200 //
 201 /*
 202 SIG_HOLD
 203
 204 sigset_t
 205 pid_t   (defined in sys.types)
 206
 207 SIGABRT (defined in stdc.signal)
 208 SIGFPE  (defined in stdc.signal)
 209 SIGILL  (defined in stdc.signal)
 210 SIGINT  (defined in stdc.signal)
 211 SIGSEGV (defined in stdc.signal)
 212 SIGTERM (defined in stdc.signal)
 213
 214 SA_NOCLDSTOP (CX|XSI)
 215 SIG_BLOCK
 216 SIG_UNBLOCK
 217 SIG_SETMASK
 218
 219 struct siginfo_t
 220 {
 221     int     si_signo;
 222     int     si_code;
 223
 224     version( XSI )
 225     {
 226         int     si_errno;
 227         pid_t   si_pid;
 228         uid_t   si_uid;
 229         void*   si_addr;
 230         int     si_status;
 231         c_long  si_band;
 232     }
 233     version( RTS )
 234     {
 235         sigval  si_value;
 236     }
 237 }
 238
 239 SI_USER
 240 SI_QUEUE
 241 SI_TIMER
 242 SI_ASYNCIO
 243 SI_MESGQ
 244
 245 int kill(pid_t, int);
 246 int sigaction(int, in sigaction_t*, sigaction_t*);
 247 int sigaddset(sigset_t*, int);
 248 int sigdelset(sigset_t*, int);
 249 int sigemptyset(sigset_t*);
 250 int sigfillset(sigset_t*);
 251 int sigismember(in sigset_t*, int);
 252 int sigpending(sigset_t*);
 253 int sigprocmask(int, in sigset_t*, sigset_t*);
 254 int sigsuspend(in sigset_t*);
 255 int sigwait(in sigset_t*, int*);
 256 */
 257
 258 version( linux )
 259 {
 260     const SIG_HOLD = cast(sigfn_t) 1;
 261
 262     private const _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof);
 263
 264     struct sigset_t
 265     {
 266         c_ulong[_SIGSET_NWORDS] __val;
 267     }
 268
 269     // pid_t  (defined in sys.types)
 270
 271     //SIGABRT (defined in stdc.signal)
 272     //SIGFPE  (defined in stdc.signal)
 273     //SIGILL  (defined in stdc.signal)
 274     //SIGINT  (defined in stdc.signal)
 275     //SIGSEGV (defined in stdc.signal)
 276     //SIGTERM (defined in stdc.signal)
 277
 278     const SA_NOCLDSTOP  = 1; // (CX|XSI)
 279
 280     const SIG_BLOCK     = 0;
 281     const SIG_UNBLOCK   = 1;
 282     const SIG_SETMASK   = 2;
 283
 284     private const __SI_MAX_SIZE = 128;
 285
 286     static if( false /* __WORDSIZE == 64 */ )
 287     {
 288         private const __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
 289     }
 290     else
 291     {
 292         private const __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3);
 293     }
 294
 295     struct siginfo_t
 296     {
 297         int si_signo;       // Signal number
 298         int si_errno;       // If non-zero, an errno value associated with
 299                             // this signal, as defined in <errno.h>
 300         int si_code;        // Signal code
 301
 302         union _sifields_t
 303         {
 304             int _pad[__SI_PAD_SIZE];
 305
 306             // kill()
 307             struct _kill_t
 308             {
 309                 pid_t si_pid; // Sending process ID
 310                 uid_t si_uid; // Real user ID of sending process
 311             } _kill_t _kill;
 312
 313             // POSIX.1b timers.
 314             struct _timer_t
 315             {
 316                 int    si_tid;     // Timer ID
 317                 int    si_overrun; // Overrun count
 318                 sigval si_sigval;  // Signal value
 319             } _timer_t _timer;
 320
 321             // POSIX.1b signals
 322             struct _rt_t
 323             {
 324                 pid_t  si_pid;    // Sending process ID
 325                 uid_t  si_uid;    // Real user ID of sending process
 326                 sigval si_sigval; // Signal value
 327             } _rt_t _rt;
 328
 329             // SIGCHLD
 330             struct _sigchild_t
 331             {
 332                 pid_t   si_pid;    // Which child
 333                 uid_t   si_uid;    // Real user ID of sending process
 334                 int     si_status; // Exit value or signal
 335                 clock_t si_utime;
 336                 clock_t si_stime;
 337             } _sigchild_t _sigchld;
 338
 339             // SIGILL, SIGFPE, SIGSEGV, SIGBUS
 340             struct _sigfault_t
 341             {
 342                 void*     si_addr;  // Faulting insn/memory ref
 343             } _sigfault_t _sigfault;
 344
 345             // SIGPOLL
 346             struct _sigpoll_t
 347             {
 348                 c_long   si_band;   // Band event for SIGPOLL
 349                 int      si_fd;
 350             } _sigpoll_t _sigpoll;
 351         } _sifields_t _sifields;
 352     }
 353
 354     enum
 355     {
 356         SI_ASYNCNL = -60,
 357         SI_TKILL   = -6,
 358         SI_SIGIO,
 359         SI_ASYNCIO,
 360         SI_MESGQ,
 361         SI_TIMER,
 362         SI_QUEUE,
 363         SI_USER,
 364         SI_KERNEL  = 0x80
 365     }
 366
 367     int kill(pid_t, int);
 368     int sigaction(int, in sigaction_t*, sigaction_t*);
 369     int sigaddset(sigset_t*, int);
 370     int sigdelset(sigset_t*, int);
 371     int sigemptyset(sigset_t*);
 372     int sigfillset(sigset_t*);
 373     int sigismember(in sigset_t*, int);
 374     int sigpending(sigset_t*);
 375     int sigprocmask(int, in sigset_t*, sigset_t*);
 376     int sigsuspend(in sigset_t*);
 377     int sigwait(in sigset_t*, int*);
 378 }
 379 else version( darwin )
 380 {
 381     //SIG_HOLD
 382
 383     alias uint sigset_t;
 384     // pid_t  (defined in sys.types)
 385
 386     //SIGABRT (defined in stdc.signal)
 387     //SIGFPE  (defined in stdc.signal)
 388     //SIGILL  (defined in stdc.signal)
 389     //SIGINT  (defined in stdc.signal)
 390     //SIGSEGV (defined in stdc.signal)
 391     //SIGTERM (defined in stdc.signal)
 392
 393     //SA_NOCLDSTOP (CX|XSI)
 394
 395     //SIG_BLOCK
 396     //SIG_UNBLOCK
 397     //SIG_SETMASK
 398
 399     struct siginfo_t
 400     {
 401         int     si_signo;
 402         int     si_errno;
 403         int     si_code;
 404         pid_t   si_pid;
 405         uid_t   si_uid;
 406         int     si_status;
 407         void*   si_addr;
 408         sigval  si_value;
 409         int     si_band;
 410         uint    pad[7];
 411     }
 412
 413     //SI_USER
 414     //SI_QUEUE
 415     //SI_TIMER
 416     //SI_ASYNCIO
 417     //SI_MESGQ
 418
 419     int kill(pid_t, int);
 420     int sigaction(int, in sigaction_t*, sigaction_t*);
 421     int sigaddset(sigset_t*, int);
 422     int sigdelset(sigset_t*, int);
 423     int sigemptyset(sigset_t*);
 424     int sigfillset(sigset_t*);
 425     int sigismember(in sigset_t*, int);
 426     int sigpending(sigset_t*);
 427     int sigprocmask(int, in sigset_t*, sigset_t*);
 428     int sigsuspend(in sigset_t*);
 429     int sigwait(in sigset_t*, int*);
 430 }
 431 else version( freebsd )
 432 {
 433     union sigval
 434     {
 435         int sival_int;
 436         void* sival_ptr;
 437         int sigval_int;
 438         void* sigval_ptr;
 439     }
 440
 441     struct sigset_t
 442     {
 443         uint __bits[4];
 444     }
 445
 446     struct siginfo_t
 447     {
 448         int si_signo;
 449         int si_errno;
 450         int si_code;
 451         pid_t si_pid;
 452         uid_t si_uid;
 453         int si_status;
 454         void* si_addr;
 455         sigval si_value;
 456         union __reason
 457         {
 458             struct __fault
 459             {
 460                 int _trapno;
 461             }
 462             __fault _fault;
 463             struct __timer
 464             {
 465                 int _timerid;
 466                 int _overrun;
 467             }
 468             __timer _timer;
 469             struct __mesgq
 470             {
 471                 int _mqd;
 472             }
 473             __mesgq _mesgq;
 474             struct __poll
 475             {
 476                 c_long _band;
 477             }
 478             __poll _poll;
 479             struct ___spare___
 480             {
 481                 c_long __spare1__;
 482                 int[7] __spare2__;
 483             }
 484             ___spare___ __spare__;
 485         }
 486         __reason _reason;
 487     }
 488
 489     int kill(pid_t, int);
 490     int sigaction(int, in sigaction_t*, sigaction_t);
 491     int sigaddset(sigset_t*, int);
 492     int sigdelset(sigset_t*, int);
 493     int sigemptyset(sigset_t *);
 494     int sigfillset(sigset_t *);
 495     int sigismember(in sigset_t *, int);
 496     int sigpending(sigset_t *);
 497     int sigprocmask(int, in sigset_t*, sigset_t*);
 498     int sigsuspend(in sigset_t *);
 499     int sigwait(in sigset_t*, int*);
 500 }
 501
 502
 503 //
 504 // XOpen (XSI)
 505 //
 506 /*
 507 SIGPOLL
 508 SIGPROF
 509 SIGSYS
 510 SIGTRAP
 511 SIGVTALRM
 512 SIGXCPU
 513 SIGXFSZ
 514
 515 SA_ONSTACK
 516 SA_RESETHAND
 517 SA_RESTART
 518 SA_SIGINFO
 519 SA_NOCLDWAIT
 520 SA_NODEFER
 521 SS_ONSTACK
 522 SS_DISABLE
 523 MINSIGSTKSZ
 524 SIGSTKSZ
 525
 526 ucontext_t // from ucontext
 527 mcontext_t // from ucontext
 528
 529 struct stack_t
 530 {
 531     void*   ss_sp;
 532     size_t  ss_size;
 533     int     ss_flags;
 534 }
 535
 536 struct sigstack
 537 {
 538     int   ss_onstack;
 539     void* ss_sp;
 540 }
 541
 542 ILL_ILLOPC
 543 ILL_ILLOPN
 544 ILL_ILLADR
 545 ILL_ILLTRP
 546 ILL_PRVOPC
 547 ILL_PRVREG
 548 ILL_COPROC
 549 ILL_BADSTK
 550
 551 FPE_INTDIV
 552 FPE_INTOVF
 553 FPE_FLTDIV
 554 FPE_FLTOVF
 555 FPE_FLTUND
 556 FPE_FLTRES
 557 FPE_FLTINV
 558 FPE_FLTSUB
 559
 560 SEGV_MAPERR
 561 SEGV_ACCERR
 562
 563 BUS_ADRALN
 564 BUS_ADRERR
 565 BUS_OBJERR
 566
 567 TRAP_BRKPT
 568 TRAP_TRACE
 569
 570 CLD_EXITED
 571 CLD_KILLED
 572 CLD_DUMPED
 573 CLD_TRAPPED
 574 CLD_STOPPED
 575 CLD_CONTINUED
 576
 577 POLL_IN
 578 POLL_OUT
 579 POLL_MSG
 580 POLL_ERR
 581 POLL_PRI
 582 POLL_HUP
 583
 584 sigfn_t bsd_signal(int sig, sigfn_t func);
 585 sigfn_t sigset(int sig, sigfn_t func);
 586
 587 int killpg(pid_t, int);
 588 int sigaltstack(in stack_t*, stack_t*);
 589 int sighold(int);
 590 int sigignore(int);
 591 int siginterrupt(int, int);
 592 int sigpause(int);
 593 int sigrelse(int);
 594 */
 595
 596 version( linux )
 597 {
 598     const SIGPOLL       = 29;
 599     const SIGPROF       = 27;
 600     const SIGSYS        = 31;
 601     const SIGTRAP       = 5;
 602     const SIGVTALRM     = 26;
 603     const SIGXCPU       = 24;
 604     const SIGXFSZ       = 25;
 605
 606     const SA_ONSTACK    = 0x08000000;
 607     const SA_RESETHAND  = 0x80000000;
 608     const SA_RESTART    = 0x10000000;
 609     const SA_SIGINFO    = 4;
 610     const SA_NOCLDWAIT  = 2;
 611     const SA_NODEFER    = 0x40000000;
 612     const SS_ONSTACK    = 1;
 613     const SS_DISABLE    = 2;
 614     const MINSIGSTKSZ   = 2048;
 615     const SIGSTKSZ      = 8192;
 616
 617     //ucontext_t (defined in stdc.posix.ucontext)
 618     //mcontext_t (defined in stdc.posix.ucontext)
 619
 620     struct stack_t
 621     {
 622         void*   ss_sp;
 623         int     ss_flags;
 624         size_t  ss_size;
 625     }
 626
 627     struct sigstack
 628     {
 629         void*   ss_sp;
 630         int     ss_onstack;
 631     }
 632
 633     enum
 634     {
 635         ILL_ILLOPC = 1,
 636         ILL_ILLOPN,
 637         ILL_ILLADR,
 638         ILL_ILLTRP,
 639         ILL_PRVOPC,
 640         ILL_PRVREG,
 641         ILL_COPROC,
 642         ILL_BADSTK
 643     }
 644
 645     enum
 646     {
 647         FPE_INTDIV = 1,
 648         FPE_INTOVF,
 649         FPE_FLTDIV,
 650         FPE_FLTOVF,
 651         FPE_FLTUND,
 652         FPE_FLTRES,
 653         FPE_FLTINV,
 654         FPE_FLTSUB
 655     }
 656
 657     enum
 658     {
 659         SEGV_MAPERR = 1,
 660         SEGV_ACCERR
 661     }
 662
 663     enum
 664     {
 665         BUS_ADRALN = 1,
 666         BUS_ADRERR,
 667         BUS_OBJERR
 668     }
 669
 670     enum
 671     {
 672         TRAP_BRKPT = 1,
 673         TRAP_TRACE
 674     }
 675
 676     enum
 677     {
 678         CLD_EXITED = 1,
 679         CLD_KILLED,
 680         CLD_DUMPED,
 681         CLD_TRAPPED,
 682         CLD_STOPPED,
 683         CLD_CONTINUED
 684     }
 685
 686     enum
 687     {
 688         POLL_IN = 1,
 689         POLL_OUT,
 690         POLL_MSG,
 691         POLL_ERR,
 692         POLL_PRI,
 693         POLL_HUP
 694     }
 695
 696     sigfn_t bsd_signal(int sig, sigfn_t func);
 697     sigfn_t sigset(int sig, sigfn_t func);
 698
 699     int killpg(pid_t, int);
 700     int sigaltstack(in stack_t*, stack_t*);
 701     int sighold(int);
 702     int sigignore(int);
 703     int siginterrupt(int, int);
 704     int sigpause(int);
 705     int sigrelse(int);
 706 }
 707
 708 //
 709 // Timer (TMR)
 710 //
 711 /*
 712 NOTE: This should actually be defined in stdc.posix.time.
 713       It is defined here instead to break a circular import.
 714
 715 struct timespec
 716 {
 717     time_t  tv_sec;
 718     int     tv_nsec;
 719 }
 720 */
 721
 722 version( linux )
 723 {
 724     struct timespec
 725     {
 726         time_t  tv_sec;
 727         c_long  tv_nsec;
 728     }
 729 }
 730 else version( darwin )
 731 {
 732     struct timespec
 733     {
 734         time_t  tv_sec;
 735         c_long  tv_nsec;
 736     }
 737 }
 738 else version( freebsd )
 739 {
 740     struct timespec
 741     {
 742         time_t  tv_sec;
 743         c_long  tv_nsec;
 744     }
 745 }
 746
 747 //
 748 // Realtime Signals (RTS)
 749 //
 750 /*
 751 struct sigevent
 752 {
 753     int             sigev_notify;
 754     int             sigev_signo;
 755     sigval          sigev_value;
 756     void(*)(sigval) sigev_notify_function;
 757     pthread_attr_t* sigev_notify_attributes;
 758 }
 759
 760 int sigqueue(pid_t, int, in sigval);
 761 int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*);
 762 int sigwaitinfo(in sigset_t*, siginfo_t*);
 763 */
 764
 765 version( linux )
 766 {
 767     private const __SIGEV_MAX_SIZE = 64;
 768
 769     static if( false /* __WORDSIZE == 64 */ )
 770     {
 771         private const __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
 772     }
 773     else
 774     {
 775         private const __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3);
 776     }
 777
 778     struct sigevent
 779     {
 780         sigval      sigev_value;
 781         int         sigev_signo;
 782         int         sigev_notify;
 783
 784         union _sigev_un_t
 785         {
 786             int[__SIGEV_PAD_SIZE] _pad;
 787             pid_t                 _tid;
 788
 789             struct _sigev_thread_t
 790             {
 791                 void function(sigval)   _function;
 792                 void*                   _attribute;
 793             } _sigev_thread_t _sigev_thread;
 794         } _sigev_un_t _sigev_un;
 795     }
 796
 797     int sigqueue(pid_t, int, in sigval);
 798     int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*);
 799     int sigwaitinfo(in sigset_t*, siginfo_t*);
 800 }
 801
 802 //
 803 // Threads (THR)
 804 //
 805 /*
 806 int pthread_kill(pthread_t, int);
 807 int pthread_sigmask(int, in sigset_t*, sigset_t*);
 808 */
 809
 810 version( linux )
 811 {
 812     int pthread_kill(pthread_t, int);
 813     int pthread_sigmask(int, in sigset_t*, sigset_t*);
 814 }
 815 else version( darwin )
 816 {
 817     int pthread_kill(pthread_t, int);
 818     int pthread_sigmask(int, in sigset_t*, sigset_t*);
 819 }
 820 else version( freebsd )
 821 {
 822     int pthread_kill(pthread_t, int);
 823     int pthread_sigmask(int, in sigset_t*, sigset_t*);
 824 }