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