ext/POSIX/POSIX.pm

   1 package POSIX;
   2
   3 our(@ISA, %EXPORT_TAGS, @EXPORT_OK, $AUTOLOAD, %SIGRT) = ();
   4
   5 our $VERSION = "1.10";
   6
   7 use AutoLoader;
   8
   9 use XSLoader ();
  10
  11 # Grandfather old foo_h form to new :foo_h form
  12 my $loaded;
  13
  14 sub import {
  15     load_imports() unless $loaded++;
  16     my $this = shift;
  17     my @list = map { m/^\w+_h$/ ? ":$_" : $_ } @_;
  18     local $Exporter::ExportLevel = 1;
  19     Exporter::import($this,@list);
  20 }
  21
  22 sub croak { require Carp;  goto &Carp::croak }
  23 # declare usage to assist AutoLoad
  24 sub usage;
  25
  26 XSLoader::load 'POSIX', $VERSION;
  27
  28 my %NON_CONSTS = (map {($_,1)}
  29                   qw(S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG WEXITSTATUS
  30                      WIFEXITED WIFSIGNALED WIFSTOPPED WSTOPSIG WTERMSIG));
  31
  32 sub AUTOLOAD {
  33     if ($AUTOLOAD =~ /::(_?[a-z])/) {
  34         # require AutoLoader;
  35         $AutoLoader::AUTOLOAD = $AUTOLOAD;
  36         goto &AutoLoader::AUTOLOAD
  37     }
  38     local $! = 0;
  39     my $constname = $AUTOLOAD;
  40     $constname =~ s/.*:://;
  41     if ($NON_CONSTS{$constname}) {
  42         my ($val, $error) = &int_macro_int($constname, $_[0]);
  43         croak $error if $error;
  44         *$AUTOLOAD = sub { &int_macro_int($constname, $_[0]) };
  45     } else {
  46         my ($error, $val) = constant($constname);
  47         croak $error if $error;
  48         *$AUTOLOAD = sub { $val };
  49     }
  50
  51     goto &$AUTOLOAD;
  52 }
  53
  54 package POSIX::SigAction;
  55
  56 use AutoLoader 'AUTOLOAD';
  57 sub new { bless {HANDLER => $_[1], MASK => $_[2], FLAGS => $_[3] || 0, SAFE => 0}, $_[0] }
  58
  59 package POSIX::SigRt;
  60
  61 use strict;
  62
  63 use Tie::Hash;
  64 use base qw(Tie::StdHash);
  65
  66 use vars qw($SIGACTION_FLAGS);
  67
  68 $SIGACTION_FLAGS = 0;
  69
  70 my ($SIGRTMIN, $SIGRTMAX, $sigrtn);
  71
  72 sub _init {
  73     $SIGRTMIN = &POSIX::SIGRTMIN;
  74     $SIGRTMAX = &POSIX::SIGRTMAX;
  75     $sigrtn   = $SIGRTMAX - $SIGRTMIN;
  76 }
  77
  78 sub _croak {
  79     &_init unless defined $sigrtn;
  80     die "POSIX::SigRt not available" unless defined $sigrtn && $sigrtn > 0;
  81 }
  82
  83 sub _getsig {
  84     &_croak;
  85     my $rtsig = $_[0];
  86     # Allow (SIGRT)?MIN( + n)?, a common idiom when doing these things in C.
  87     $rtsig = $SIGRTMIN + ($1 || 0)
  88         if $rtsig =~ /^(?:(?:SIG)?RT)?MIN(\s*\+\s*(\d+))?$/;
  89     return $rtsig;
  90 }
  91
  92 sub _exist {
  93     my $rtsig = _getsig($_[1]);
  94     my $ok    = $rtsig >= $SIGRTMIN && $rtsig <= $SIGRTMAX;
  95     ($rtsig, $ok);
  96 }
  97
  98 sub _check {
  99     my ($rtsig, $ok) = &_exist;
 100     die "No POSIX::SigRt signal $_[1] (valid range SIGRTMIN..SIGRTMAX, or $SIGRTMIN..$SIGRTMAX)"
 101         unless $ok;
 102     return $rtsig;
 103 }
 104
 105 sub new {
 106     my ($rtsig, $handler, $flags) = @_;
 107     my $sigset = POSIX::SigSet->new($rtsig);
 108     my $sigact = POSIX::SigAction->new($handler,
 109                                        $sigset,
 110                                        $flags);
 111     POSIX::sigaction($rtsig, $sigact);
 112 }
 113
 114 sub EXISTS { &_exist }
 115 sub FETCH  { my $rtsig = &_check;
 116              my $oa = POSIX::SigAction->new();
 117              POSIX::sigaction($rtsig, undef, $oa);
 118              return $oa->{HANDLER} }
 119 sub STORE  { my $rtsig = &_check; new($rtsig, $_[2], $SIGACTION_FLAGS) }
 120 sub DELETE { delete $SIG{ &_check } }
 121 sub CLEAR  { &_exist; delete @SIG{ &POSIX::SIGRTMIN .. &POSIX::SIGRTMAX } }
 122 sub SCALAR { &_croak; $sigrtn + 1 }
 123
 124 tie %POSIX::SIGRT, 'POSIX::SigRt';
 125
 126 package POSIX;
 127
 128 1;
 129 __END__
 130
 131 sub usage {
 132     my ($mess) = @_;
 133     croak "Usage: POSIX::$mess";
 134 }
 135
 136 sub redef {
 137     my ($mess) = @_;
 138     croak "Use method $mess instead";
 139 }
 140
 141 sub unimpl {
 142     my ($mess) = @_;
 143     $mess =~ s/xxx//;
 144     croak "Unimplemented: POSIX::$mess";
 145 }
 146
 147 sub assert {
 148     usage "assert(expr)" if @_ != 1;
 149     if (!$_[0]) {
 150         croak "Assertion failed";
 151     }
 152 }
 153
 154 sub tolower {
 155     usage "tolower(string)" if @_ != 1;
 156     lc($_[0]);
 157 }
 158
 159 sub toupper {
 160     usage "toupper(string)" if @_ != 1;
 161     uc($_[0]);
 162 }
 163
 164 sub closedir {
 165     usage "closedir(dirhandle)" if @_ != 1;
 166     CORE::closedir($_[0]);
 167 }
 168
 169 sub opendir {
 170     usage "opendir(directory)" if @_ != 1;
 171     my $dirhandle;
 172     CORE::opendir($dirhandle, $_[0])
 173         ? $dirhandle
 174         : undef;
 175 }
 176
 177 sub readdir {
 178     usage "readdir(dirhandle)" if @_ != 1;
 179     CORE::readdir($_[0]);
 180 }
 181
 182 sub rewinddir {
 183     usage "rewinddir(dirhandle)" if @_ != 1;
 184     CORE::rewinddir($_[0]);
 185 }
 186
 187 sub errno {
 188     usage "errno()" if @_ != 0;
 189     $! + 0;
 190 }
 191
 192 sub creat {
 193     usage "creat(filename, mode)" if @_ != 2;
 194     &open($_[0], &O_WRONLY | &O_CREAT | &O_TRUNC, $_[1]);
 195 }
 196
 197 sub fcntl {
 198     usage "fcntl(filehandle, cmd, arg)" if @_ != 3;
 199     CORE::fcntl($_[0], $_[1], $_[2]);
 200 }
 201
 202 sub getgrgid {
 203     usage "getgrgid(gid)" if @_ != 1;
 204     CORE::getgrgid($_[0]);
 205 }
 206
 207 sub getgrnam {
 208     usage "getgrnam(name)" if @_ != 1;
 209     CORE::getgrnam($_[0]);
 210 }
 211
 212 sub atan2 {
 213     usage "atan2(x,y)" if @_ != 2;
 214     CORE::atan2($_[0], $_[1]);
 215 }
 216
 217 sub cos {
 218     usage "cos(x)" if @_ != 1;
 219     CORE::cos($_[0]);
 220 }
 221
 222 sub exp {
 223     usage "exp(x)" if @_ != 1;
 224     CORE::exp($_[0]);
 225 }
 226
 227 sub fabs {
 228     usage "fabs(x)" if @_ != 1;
 229     CORE::abs($_[0]);
 230 }
 231
 232 sub log {
 233     usage "log(x)" if @_ != 1;
 234     CORE::log($_[0]);
 235 }
 236
 237 sub pow {
 238     usage "pow(x,exponent)" if @_ != 2;
 239     $_[0] ** $_[1];
 240 }
 241
 242 sub sin {
 243     usage "sin(x)" if @_ != 1;
 244     CORE::sin($_[0]);
 245 }
 246
 247 sub sqrt {
 248     usage "sqrt(x)" if @_ != 1;
 249     CORE::sqrt($_[0]);
 250 }
 251
 252 sub getpwnam {
 253     usage "getpwnam(name)" if @_ != 1;
 254     CORE::getpwnam($_[0]);
 255 }
 256
 257 sub getpwuid {
 258     usage "getpwuid(uid)" if @_ != 1;
 259     CORE::getpwuid($_[0]);
 260 }
 261
 262 sub longjmp {
 263     unimpl "longjmp() is C-specific: use die instead";
 264 }
 265
 266 sub setjmp {
 267     unimpl "setjmp() is C-specific: use eval {} instead";
 268 }
 269
 270 sub siglongjmp {
 271     unimpl "siglongjmp() is C-specific: use die instead";
 272 }
 273
 274 sub sigsetjmp {
 275     unimpl "sigsetjmp() is C-specific: use eval {} instead";
 276 }
 277
 278 sub kill {
 279     usage "kill(pid, sig)" if @_ != 2;
 280     CORE::kill $_[1], $_[0];
 281 }
 282
 283 sub raise {
 284     usage "raise(sig)" if @_ != 1;
 285     CORE::kill $_[0], $$;       # Is this good enough?
 286 }
 287
 288 sub offsetof {
 289     unimpl "offsetof() is C-specific, stopped";
 290 }
 291
 292 sub clearerr {
 293     redef "IO::Handle::clearerr()";
 294 }
 295
 296 sub fclose {
 297     redef "IO::Handle::close()";
 298 }
 299
 300 sub fdopen {
 301     redef "IO::Handle::new_from_fd()";
 302 }
 303
 304 sub feof {
 305     redef "IO::Handle::eof()";
 306 }
 307
 308 sub fgetc {
 309     redef "IO::Handle::getc()";
 310 }
 311
 312 sub fgets {
 313     redef "IO::Handle::gets()";
 314 }
 315
 316 sub fileno {
 317     redef "IO::Handle::fileno()";
 318 }
 319
 320 sub fopen {
 321     redef "IO::File::open()";
 322 }
 323
 324 sub fprintf {
 325     unimpl "fprintf() is C-specific--use printf instead";
 326 }
 327
 328 sub fputc {
 329     unimpl "fputc() is C-specific--use print instead";
 330 }
 331
 332 sub fputs {
 333     unimpl "fputs() is C-specific--use print instead";
 334 }
 335
 336 sub fread {
 337     unimpl "fread() is C-specific--use read instead";
 338 }
 339
 340 sub freopen {
 341     unimpl "freopen() is C-specific--use open instead";
 342 }
 343
 344 sub fscanf {
 345     unimpl "fscanf() is C-specific--use <> and regular expressions instead";
 346 }
 347
 348 sub fseek {
 349     redef "IO::Seekable::seek()";
 350 }
 351
 352 sub fsync {
 353     redef "IO::Handle::sync()";
 354 }
 355
 356 sub ferror {
 357     redef "IO::Handle::error()";
 358 }
 359
 360 sub fflush {
 361     redef "IO::Handle::flush()";
 362 }
 363
 364 sub fgetpos {
 365     redef "IO::Seekable::getpos()";
 366 }
 367
 368 sub fsetpos {
 369     redef "IO::Seekable::setpos()";
 370 }
 371
 372 sub ftell {
 373     redef "IO::Seekable::tell()";
 374 }
 375
 376 sub fwrite {
 377     unimpl "fwrite() is C-specific--use print instead";
 378 }
 379
 380 sub getc {
 381     usage "getc(handle)" if @_ != 1;
 382     CORE::getc($_[0]);
 383 }
 384
 385 sub getchar {
 386     usage "getchar()" if @_ != 0;
 387     CORE::getc(STDIN);
 388 }
 389
 390 sub gets {
 391     usage "gets()" if @_ != 0;
 392     scalar <STDIN>;
 393 }
 394
 395 sub perror {
 396     print STDERR "@_: " if @_;
 397     print STDERR $!,"\n";
 398 }
 399
 400 sub printf {
 401     usage "printf(pattern, args...)" if @_ < 1;
 402     CORE::printf STDOUT @_;
 403 }
 404
 405 sub putc {
 406     unimpl "putc() is C-specific--use print instead";
 407 }
 408
 409 sub putchar {
 410     unimpl "putchar() is C-specific--use print instead";
 411 }
 412
 413 sub puts {
 414     unimpl "puts() is C-specific--use print instead";
 415 }
 416
 417 sub remove {
 418     usage "remove(filename)" if @_ != 1;
 419     CORE::unlink($_[0]);
 420 }
 421
 422 sub rename {
 423     usage "rename(oldfilename, newfilename)" if @_ != 2;
 424     CORE::rename($_[0], $_[1]);
 425 }
 426
 427 sub rewind {
 428     usage "rewind(filehandle)" if @_ != 1;
 429     CORE::seek($_[0],0,0);
 430 }
 431
 432 sub scanf {
 433     unimpl "scanf() is C-specific--use <> and regular expressions instead";
 434 }
 435
 436 sub sprintf {
 437     usage "sprintf(pattern,args)" if @_ == 0;
 438     CORE::sprintf(shift,@_);
 439 }
 440
 441 sub sscanf {
 442     unimpl "sscanf() is C-specific--use regular expressions instead";
 443 }
 444
 445 sub tmpfile {
 446     redef "IO::File::new_tmpfile()";
 447 }
 448
 449 sub ungetc {
 450     redef "IO::Handle::ungetc()";
 451 }
 452
 453 sub vfprintf {
 454     unimpl "vfprintf() is C-specific";
 455 }
 456
 457 sub vprintf {
 458     unimpl "vprintf() is C-specific";
 459 }
 460
 461 sub vsprintf {
 462     unimpl "vsprintf() is C-specific";
 463 }
 464
 465 sub abs {
 466     usage "abs(x)" if @_ != 1;
 467     CORE::abs($_[0]);
 468 }
 469
 470 sub atexit {
 471     unimpl "atexit() is C-specific: use END {} instead";
 472 }
 473
 474 sub atof {
 475     unimpl "atof() is C-specific, stopped";
 476 }
 477
 478 sub atoi {
 479     unimpl "atoi() is C-specific, stopped";
 480 }
 481
 482 sub atol {
 483     unimpl "atol() is C-specific, stopped";
 484 }
 485
 486 sub bsearch {
 487     unimpl "bsearch() not supplied";
 488 }
 489
 490 sub calloc {
 491     unimpl "calloc() is C-specific, stopped";
 492 }
 493
 494 sub div {
 495     unimpl "div() is C-specific, use /, % and int instead";
 496 }
 497
 498 sub exit {
 499     usage "exit(status)" if @_ != 1;
 500     CORE::exit($_[0]);
 501 }
 502
 503 sub free {
 504     unimpl "free() is C-specific, stopped";
 505 }
 506
 507 sub getenv {
 508     usage "getenv(name)" if @_ != 1;
 509     $ENV{$_[0]};
 510 }
 511
 512 sub labs {
 513     unimpl "labs() is C-specific, use abs instead";
 514 }
 515
 516 sub ldiv {
 517     unimpl "ldiv() is C-specific, use /, % and int instead";
 518 }
 519
 520 sub malloc {
 521     unimpl "malloc() is C-specific, stopped";
 522 }
 523
 524 sub qsort {
 525     unimpl "qsort() is C-specific, use sort instead";
 526 }
 527
 528 sub rand {
 529     unimpl "rand() is non-portable, use Perl's rand instead";
 530 }
 531
 532 sub realloc {
 533     unimpl "realloc() is C-specific, stopped";
 534 }
 535
 536 sub srand {
 537     unimpl "srand()";
 538 }
 539
 540 sub system {
 541     usage "system(command)" if @_ != 1;
 542     CORE::system($_[0]);
 543 }
 544
 545 sub memchr {
 546     unimpl "memchr() is C-specific, use index() instead";
 547 }
 548
 549 sub memcmp {
 550     unimpl "memcmp() is C-specific, use eq instead";
 551 }
 552
 553 sub memcpy {
 554     unimpl "memcpy() is C-specific, use = instead";
 555 }
 556
 557 sub memmove {
 558     unimpl "memmove() is C-specific, use = instead";
 559 }
 560
 561 sub memset {
 562     unimpl "memset() is C-specific, use x instead";
 563 }
 564
 565 sub strcat {
 566     unimpl "strcat() is C-specific, use .= instead";
 567 }
 568
 569 sub strchr {
 570     unimpl "strchr() is C-specific, use index() instead";
 571 }
 572
 573 sub strcmp {
 574     unimpl "strcmp() is C-specific, use eq instead";
 575 }
 576
 577 sub strcpy {
 578     unimpl "strcpy() is C-specific, use = instead";
 579 }
 580
 581 sub strcspn {
 582     unimpl "strcspn() is C-specific, use regular expressions instead";
 583 }
 584
 585 sub strerror {
 586     usage "strerror(errno)" if @_ != 1;
 587     local $! = $_[0];
 588     $! . "";
 589 }
 590
 591 sub strlen {
 592     unimpl "strlen() is C-specific, use length instead";
 593 }
 594
 595 sub strncat {
 596     unimpl "strncat() is C-specific, use .= instead";
 597 }
 598
 599 sub strncmp {
 600     unimpl "strncmp() is C-specific, use eq instead";
 601 }
 602
 603 sub strncpy {
 604     unimpl "strncpy() is C-specific, use = instead";
 605 }
 606
 607 sub strpbrk {
 608     unimpl "strpbrk() is C-specific, stopped";
 609 }
 610
 611 sub strrchr {
 612     unimpl "strrchr() is C-specific, use rindex() instead";
 613 }
 614
 615 sub strspn {
 616     unimpl "strspn() is C-specific, stopped";
 617 }
 618
 619 sub strstr {
 620     usage "strstr(big, little)" if @_ != 2;
 621     CORE::index($_[0], $_[1]);
 622 }
 623
 624 sub strtok {
 625     unimpl "strtok() is C-specific, stopped";
 626 }
 627
 628 sub chmod {
 629     usage "chmod(mode, filename)" if @_ != 2;
 630     CORE::chmod($_[0], $_[1]);
 631 }
 632
 633 sub fstat {
 634     usage "fstat(fd)" if @_ != 1;
 635     local *TMP;
 636     CORE::open(TMP, "<&$_[0]");         # Gross.
 637     my @l = CORE::stat(TMP);
 638     CORE::close(TMP);
 639     @l;
 640 }
 641
 642 sub mkdir {
 643     usage "mkdir(directoryname, mode)" if @_ != 2;
 644     CORE::mkdir($_[0], $_[1]);
 645 }
 646
 647 sub stat {
 648     usage "stat(filename)" if @_ != 1;
 649     CORE::stat($_[0]);
 650 }
 651
 652 sub umask {
 653     usage "umask(mask)" if @_ != 1;
 654     CORE::umask($_[0]);
 655 }
 656
 657 sub wait {
 658     usage "wait()" if @_ != 0;
 659     CORE::wait();
 660 }
 661
 662 sub waitpid {
 663     usage "waitpid(pid, options)" if @_ != 2;
 664     CORE::waitpid($_[0], $_[1]);
 665 }
 666
 667 sub gmtime {
 668     usage "gmtime(time)" if @_ != 1;
 669     CORE::gmtime($_[0]);
 670 }
 671
 672 sub localtime {
 673     usage "localtime(time)" if @_ != 1;
 674     CORE::localtime($_[0]);
 675 }
 676
 677 sub time {
 678     usage "time()" if @_ != 0;
 679     CORE::time;
 680 }
 681
 682 sub alarm {
 683     usage "alarm(seconds)" if @_ != 1;
 684     CORE::alarm($_[0]);
 685 }
 686
 687 sub chdir {
 688     usage "chdir(directory)" if @_ != 1;
 689     CORE::chdir($_[0]);
 690 }
 691
 692 sub chown {
 693     usage "chown(uid, gid, filename)" if @_ != 3;
 694     CORE::chown($_[0], $_[1], $_[2]);
 695 }
 696
 697 sub execl {
 698     unimpl "execl() is C-specific, stopped";
 699 }
 700
 701 sub execle {
 702     unimpl "execle() is C-specific, stopped";
 703 }
 704
 705 sub execlp {
 706     unimpl "execlp() is C-specific, stopped";
 707 }
 708
 709 sub execv {
 710     unimpl "execv() is C-specific, stopped";
 711 }
 712
 713 sub execve {
 714     unimpl "execve() is C-specific, stopped";
 715 }
 716
 717 sub execvp {
 718     unimpl "execvp() is C-specific, stopped";
 719 }
 720
 721 sub fork {
 722     usage "fork()" if @_ != 0;
 723     CORE::fork;
 724 }
 725
 726 sub getegid {
 727     usage "getegid()" if @_ != 0;
 728     $) + 0;
 729 }
 730
 731 sub geteuid {
 732     usage "geteuid()" if @_ != 0;
 733     $> + 0;
 734 }
 735
 736 sub getgid {
 737     usage "getgid()" if @_ != 0;
 738     $( + 0;
 739 }
 740
 741 sub getgroups {
 742     usage "getgroups()" if @_ != 0;
 743     my %seen;
 744     grep(!$seen{$_}++, split(' ', $) ));
 745 }
 746
 747 sub getlogin {
 748     usage "getlogin()" if @_ != 0;
 749     CORE::getlogin();
 750 }
 751
 752 sub getpgrp {
 753     usage "getpgrp()" if @_ != 0;
 754     CORE::getpgrp;
 755 }
 756
 757 sub getpid {
 758     usage "getpid()" if @_ != 0;
 759     $$;
 760 }
 761
 762 sub getppid {
 763     usage "getppid()" if @_ != 0;
 764     CORE::getppid;
 765 }
 766
 767 sub getuid {
 768     usage "getuid()" if @_ != 0;
 769     $<;
 770 }
 771
 772 sub isatty {
 773     usage "isatty(filehandle)" if @_ != 1;
 774     -t $_[0];
 775 }
 776
 777 sub link {
 778     usage "link(oldfilename, newfilename)" if @_ != 2;
 779     CORE::link($_[0], $_[1]);
 780 }
 781
 782 sub rmdir {
 783     usage "rmdir(directoryname)" if @_ != 1;
 784     CORE::rmdir($_[0]);
 785 }
 786
 787 sub setbuf {
 788     redef "IO::Handle::setbuf()";
 789 }
 790
 791 sub setvbuf {
 792     redef "IO::Handle::setvbuf()";
 793 }
 794
 795 sub sleep {
 796     usage "sleep(seconds)" if @_ != 1;
 797     $_[0] - CORE::sleep($_[0]);
 798 }
 799
 800 sub unlink {
 801     usage "unlink(filename)" if @_ != 1;
 802     CORE::unlink($_[0]);
 803 }
 804
 805 sub utime {
 806     usage "utime(filename, atime, mtime)" if @_ != 3;
 807     CORE::utime($_[1], $_[2], $_[0]);
 808 }
 809
 810 sub load_imports {
 811 %EXPORT_TAGS = (
 812
 813     assert_h => [qw(assert NDEBUG)],
 814
 815     ctype_h =>  [qw(isalnum isalpha iscntrl isdigit isgraph islower
 816                 isprint ispunct isspace isupper isxdigit tolower toupper)],
 817
 818     dirent_h => [],
 819
 820     errno_h =>  [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT
 821                 EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED
 822                 ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT
 823                 EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS
 824                 EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK
 825                 EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH
 826                 ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM
 827                 ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR
 828                 ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM
 829                 EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE
 830                 ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT
 831                 ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY
 832                 EUSERS EWOULDBLOCK EXDEV errno)],
 833
 834     fcntl_h =>  [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK
 835                 F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK
 836                 O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK
 837                 O_RDONLY O_RDWR O_TRUNC O_WRONLY
 838                 creat
 839                 SEEK_CUR SEEK_END SEEK_SET
 840                 S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU
 841                 S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID
 842                 S_IWGRP S_IWOTH S_IWUSR)],
 843
 844     float_h =>  [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG
 845                 DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP
 846                 DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP
 847                 FLT_DIG FLT_EPSILON FLT_MANT_DIG
 848                 FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP
 849                 FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP
 850                 FLT_RADIX FLT_ROUNDS
 851                 LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG
 852                 LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP
 853                 LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)],
 854
 855     grp_h =>    [],
 856
 857     limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX
 858                 INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON
 859                 MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX
 860                 PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN
 861                 SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX
 862                 ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX
 863                 _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT
 864                 _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX
 865                 _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX
 866                 _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)],
 867
 868     locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES
 869                     LC_MONETARY LC_NUMERIC LC_TIME NULL
 870                     localeconv setlocale)],
 871
 872     math_h =>   [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod
 873                 frexp ldexp log10 modf pow sinh tan tanh)],
 874
 875     pwd_h =>    [],
 876
 877     setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)],
 878
 879     signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK
 880                 SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM
 881                 SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL
 882                 SIGPIPE %SIGRT SIGRTMIN SIGRTMAX SIGQUIT SIGSEGV SIGSTOP
 883                 SIGTERM SIGTSTP SIGTTIN SIGTTOU SIGUSR1 SIGUSR2
 884                 SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK SIG_UNBLOCK
 885                 raise sigaction signal sigpending sigprocmask sigsuspend)],
 886
 887     stdarg_h => [],
 888
 889     stddef_h => [qw(NULL offsetof)],
 890
 891     stdio_h =>  [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid
 892                 L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET
 893                 STREAM_MAX TMP_MAX stderr stdin stdout
 894                 clearerr fclose fdopen feof ferror fflush fgetc fgetpos
 895                 fgets fopen fprintf fputc fputs fread freopen
 896                 fscanf fseek fsetpos ftell fwrite getchar gets
 897                 perror putc putchar puts remove rewind
 898                 scanf setbuf setvbuf sscanf tmpfile tmpnam
 899                 ungetc vfprintf vprintf vsprintf)],
 900
 901     stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX
 902                 abort atexit atof atoi atol bsearch calloc div
 903                 free getenv labs ldiv malloc mblen mbstowcs mbtowc
 904                 qsort realloc strtod strtol strtoul wcstombs wctomb)],
 905
 906     string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat
 907                 strchr strcmp strcoll strcpy strcspn strerror strlen
 908                 strncat strncmp strncpy strpbrk strrchr strspn strstr
 909                 strtok strxfrm)],
 910
 911     sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU
 912                 S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG
 913                 S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR
 914                 fstat mkfifo)],
 915
 916     sys_times_h => [],
 917
 918     sys_types_h => [],
 919
 920     sys_utsname_h => [qw(uname)],
 921
 922     sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED
 923                 WNOHANG WSTOPSIG WTERMSIG WUNTRACED)],
 924
 925     termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400
 926                 B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL
 927                 CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK
 928                 ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR
 929                 INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST
 930                 PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION
 931                 TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW
 932                 TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART
 933                 VSTOP VSUSP VTIME
 934                 cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain
 935                 tcflow tcflush tcgetattr tcsendbreak tcsetattr )],
 936
 937     time_h =>   [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime
 938                 difftime mktime strftime tzset tzname)],
 939
 940     unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET
 941                 STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK
 942                 _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON
 943                 _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX
 944                 _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED
 945                 _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS
 946                 _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX
 947                 _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL
 948                 _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS
 949                 _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION
 950                 _exit access ctermid cuserid
 951                 dup2 dup execl execle execlp execv execve execvp
 952                 fpathconf fsync getcwd getegid geteuid getgid getgroups
 953                 getpid getuid isatty lseek pathconf pause setgid setpgid
 954                 setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)],
 955
 956     utime_h =>  [],
 957
 958 );
 959
 960 # Exporter::export_tags();
 961 {
 962   # De-duplicate the export list:
 963   my %export;
 964   @export{map {@$_} values %EXPORT_TAGS} = ();
 965   # Doing the de-dup with a temporary hash has the advantage that the SVs in
 966   # @EXPORT are actually shared hash key sacalars, which will save some memory.
 967   push @EXPORT, keys %export;
 968 }
 969
 970 @EXPORT_OK = qw(
 971                 abs
 972                 alarm
 973                 atan2
 974                 chdir
 975                 chmod
 976                 chown
 977                 close
 978                 closedir
 979                 cos
 980                 exit
 981                 exp
 982                 fcntl
 983                 fileno
 984                 fork
 985                 getc
 986                 getgrgid
 987                 getgrnam
 988                 getlogin
 989                 getpgrp
 990                 getppid
 991                 getpwnam
 992                 getpwuid
 993                 gmtime
 994                 isatty
 995                 kill
 996                 lchown
 997                 link
 998                 localtime
 999                 log
1000                 mkdir
1001                 nice
1002                 open
1003                 opendir
1004                 pipe
1005                 printf
1006                 rand
1007                 read
1008                 readdir
1009                 rename
1010                 rewinddir
1011                 rmdir
1012                 sin
1013                 sleep
1014                 sprintf
1015                 sqrt
1016                 srand
1017                 stat
1018                 system
1019                 time
1020                 times
1021                 umask
1022                 unlink
1023                 utime
1024                 wait
1025                 waitpid
1026                 write
1027 );
1028
1029 require Exporter;
1030 }
1031
1032 package POSIX::SigAction;
1033
1034 sub handler { $_[0]->{HANDLER} = $_[1] if @_ > 1; $_[0]->{HANDLER} };
1035 sub mask    { $_[0]->{MASK}    = $_[1] if @_ > 1; $_[0]->{MASK} };
1036 sub flags   { $_[0]->{FLAGS}   = $_[1] if @_ > 1; $_[0]->{FLAGS} };
1037 sub safe    { $_[0]->{SAFE}    = $_[1] if @_ > 1; $_[0]->{SAFE} };
1038