ext/POSIX/POSIX.pm

package POSIX;

our(@ISA, %EXPORT_TAGS, @EXPORT_OK, $AUTOLOAD) = ();

our $VERSION = "1.08";

use AutoLoader;

use XSLoader ();

# Grandfather old foo_h form to new :foo_h form
my $loaded;

sub import {
    load_imports() unless $loaded++;
    my $this = shift;
    my @list = map { m/^\w+_h$/ ? ":$_" : $_ } @_;
    local $Exporter::ExportLevel = 1;
    Exporter::import($this,@list);
}

sub croak { require Carp;  goto &Carp::croak }
# declare usage to assist AutoLoad
sub usage;

XSLoader::load 'POSIX', $VERSION;

my %NON_CONSTS = (map {($_,1)}
                  qw(S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG WEXITSTATUS
                     WIFEXITED WIFSIGNALED WIFSTOPPED WSTOPSIG WTERMSIG));

sub AUTOLOAD {
    if ($AUTOLOAD =~ /::(_?[a-z])/) {
        # require AutoLoader;
        $AutoLoader::AUTOLOAD = $AUTOLOAD;
        goto &AutoLoader::AUTOLOAD
    }
    local $! = 0;
    my $constname = $AUTOLOAD;
    $constname =~ s/.*:://;
    if ($NON_CONSTS{$constname}) {
        my ($val, $error) = &int_macro_int($constname, $_[0]);
        croak $error if $error;
        *$AUTOLOAD = sub { &int_macro_int($constname, $_[0]) };
    } else {
        my ($error, $val) = constant($constname);
        croak $error if $error;
        *$AUTOLOAD = sub { $val };
    }

    goto &$AUTOLOAD;
}

package POSIX::SigAction;

use AutoLoader 'AUTOLOAD';
sub new { bless {HANDLER => $_[1], MASK => $_[2], FLAGS => $_[3] || 0, SAFE => 0}, $_[0] }

package POSIX;

1;
__END__

sub usage {
    my ($mess) = @_;
    croak "Usage: POSIX::$mess";
}

sub redef {
    my ($mess) = @_;
    croak "Use method $mess instead";
}

sub unimpl {
    my ($mess) = @_;
    $mess =~ s/xxx//;
    croak "Unimplemented: POSIX::$mess";
}

sub assert {
    usage "assert(expr)" if @_ != 1;
    if (!$_[0]) {
        croak "Assertion failed";
    }
}

sub tolower {
    usage "tolower(string)" if @_ != 1;
    lc($_[0]);
}

sub toupper {
    usage "toupper(string)" if @_ != 1;
    uc($_[0]);
}

sub closedir {
    usage "closedir(dirhandle)" if @_ != 1;
    CORE::closedir($_[0]);
}

sub opendir {
    usage "opendir(directory)" if @_ != 1;
    my $dirhandle;
    CORE::opendir($dirhandle, $_[0])
        ? $dirhandle
        : undef;
}

sub readdir {
    usage "readdir(dirhandle)" if @_ != 1;
    CORE::readdir($_[0]);
}

sub rewinddir {
    usage "rewinddir(dirhandle)" if @_ != 1;
    CORE::rewinddir($_[0]);
}

sub errno {
    usage "errno()" if @_ != 0;
    $! + 0;
}

sub creat {
    usage "creat(filename, mode)" if @_ != 2;
    &open($_[0], &O_WRONLY | &O_CREAT | &O_TRUNC, $_[1]);
}

sub fcntl {
    usage "fcntl(filehandle, cmd, arg)" if @_ != 3;
    CORE::fcntl($_[0], $_[1], $_[2]);
}

sub getgrgid {
    usage "getgrgid(gid)" if @_ != 1;
    CORE::getgrgid($_[0]);
}

sub getgrnam {
    usage "getgrnam(name)" if @_ != 1;
    CORE::getgrnam($_[0]);
}

sub atan2 {
    usage "atan2(x,y)" if @_ != 2;
    CORE::atan2($_[0], $_[1]);
}

sub cos {
    usage "cos(x)" if @_ != 1;
    CORE::cos($_[0]);
}

sub exp {
    usage "exp(x)" if @_ != 1;
    CORE::exp($_[0]);
}

sub fabs {
    usage "fabs(x)" if @_ != 1;
    CORE::abs($_[0]);
}

sub log {
    usage "log(x)" if @_ != 1;
    CORE::log($_[0]);
}

sub pow {
    usage "pow(x,exponent)" if @_ != 2;
    $_[0] ** $_[1];
}

sub sin {
    usage "sin(x)" if @_ != 1;
    CORE::sin($_[0]);
}

sub sqrt {
    usage "sqrt(x)" if @_ != 1;
    CORE::sqrt($_[0]);
}

sub getpwnam {
    usage "getpwnam(name)" if @_ != 1;
    CORE::getpwnam($_[0]);
}

sub getpwuid {
    usage "getpwuid(uid)" if @_ != 1;
    CORE::getpwuid($_[0]);
}

sub longjmp {
    unimpl "longjmp() is C-specific: use die instead";
}

sub setjmp {
    unimpl "setjmp() is C-specific: use eval {} instead";
}

sub siglongjmp {
    unimpl "siglongjmp() is C-specific: use die instead";
}

sub sigsetjmp {
    unimpl "sigsetjmp() is C-specific: use eval {} instead";
}

sub kill {
    usage "kill(pid, sig)" if @_ != 2;
    CORE::kill $_[1], $_[0];
}

sub raise {
    usage "raise(sig)" if @_ != 1;
    CORE::kill $_[0], $$;       # Is this good enough?
}

sub offsetof {
    unimpl "offsetof() is C-specific, stopped";
}

sub clearerr {
    redef "IO::Handle::clearerr()";
}

sub fclose {
    redef "IO::Handle::close()";
}

sub fdopen {
    redef "IO::Handle::new_from_fd()";
}

sub feof {
    redef "IO::Handle::eof()";
}

sub fgetc {
    redef "IO::Handle::getc()";
}

sub fgets {
    redef "IO::Handle::gets()";
}

sub fileno {
    redef "IO::Handle::fileno()";
}

sub fopen {
    redef "IO::File::open()";
}

sub fprintf {
    unimpl "fprintf() is C-specific--use printf instead";
}

sub fputc {
    unimpl "fputc() is C-specific--use print instead";
}

sub fputs {
    unimpl "fputs() is C-specific--use print instead";
}

sub fread {
    unimpl "fread() is C-specific--use read instead";
}

sub freopen {
    unimpl "freopen() is C-specific--use open instead";
}

sub fscanf {
    unimpl "fscanf() is C-specific--use <> and regular expressions instead";
}

sub fseek {
    redef "IO::Seekable::seek()";
}

sub fsync {
    redef "IO::Handle::sync()";
}

sub ferror {
    redef "IO::Handle::error()";
}

sub fflush {
    redef "IO::Handle::flush()";
}

sub fgetpos {
    redef "IO::Seekable::getpos()";
}

sub fsetpos {
    redef "IO::Seekable::setpos()";
}

sub ftell {
    redef "IO::Seekable::tell()";
}

sub fwrite {
    unimpl "fwrite() is C-specific--use print instead";
}

sub getc {
    usage "getc(handle)" if @_ != 1;
    CORE::getc($_[0]);
}

sub getchar {
    usage "getchar()" if @_ != 0;
    CORE::getc(STDIN);
}

sub gets {
    usage "gets()" if @_ != 0;
    scalar <STDIN>;
}

sub perror {
    print STDERR "@_: " if @_;
    print STDERR $!,"\n";
}

sub printf {
    usage "printf(pattern, args...)" if @_ < 1;
    CORE::printf STDOUT @_;
}

sub putc {
    unimpl "putc() is C-specific--use print instead";
}

sub putchar {
    unimpl "putchar() is C-specific--use print instead";
}

sub puts {
    unimpl "puts() is C-specific--use print instead";
}

sub remove {
    usage "remove(filename)" if @_ != 1;
    CORE::unlink($_[0]);
}

sub rename {
    usage "rename(oldfilename, newfilename)" if @_ != 2;
    CORE::rename($_[0], $_[1]);
}

sub rewind {
    usage "rewind(filehandle)" if @_ != 1;
    CORE::seek($_[0],0,0);
}

sub scanf {
    unimpl "scanf() is C-specific--use <> and regular expressions instead";
}

sub sprintf {
    usage "sprintf(pattern,args)" if @_ == 0;
    CORE::sprintf(shift,@_);
}

sub sscanf {
    unimpl "sscanf() is C-specific--use regular expressions instead";
}

sub tmpfile {
    redef "IO::File::new_tmpfile()";
}

sub ungetc {
    redef "IO::Handle::ungetc()";
}

sub vfprintf {
    unimpl "vfprintf() is C-specific";
}

sub vprintf {
    unimpl "vprintf() is C-specific";
}

sub vsprintf {
    unimpl "vsprintf() is C-specific";
}

sub abs {
    usage "abs(x)" if @_ != 1;
    CORE::abs($_[0]);
}

sub atexit {
    unimpl "atexit() is C-specific: use END {} instead";
}

sub atof {
    unimpl "atof() is C-specific, stopped";
}

sub atoi {
    unimpl "atoi() is C-specific, stopped";
}

sub atol {
    unimpl "atol() is C-specific, stopped";
}

sub bsearch {
    unimpl "bsearch() not supplied";
}

sub calloc {
    unimpl "calloc() is C-specific, stopped";
}

sub div {
    unimpl "div() is C-specific, use /, % and int instead";
}

sub exit {
    usage "exit(status)" if @_ != 1;
    CORE::exit($_[0]);
}

sub free {
    unimpl "free() is C-specific, stopped";
}

sub getenv {
    usage "getenv(name)" if @_ != 1;
    $ENV{$_[0]};
}

sub labs {
    unimpl "labs() is C-specific, use abs instead";
}

sub ldiv {
    unimpl "ldiv() is C-specific, use /, % and int instead";
}

sub malloc {
    unimpl "malloc() is C-specific, stopped";
}

sub qsort {
    unimpl "qsort() is C-specific, use sort instead";
}

sub rand {
    unimpl "rand() is non-portable, use Perl's rand instead";
}

sub realloc {
    unimpl "realloc() is C-specific, stopped";
}

sub srand {
    unimpl "srand()";
}

sub system {
    usage "system(command)" if @_ != 1;
    CORE::system($_[0]);
}

sub memchr {
    unimpl "memchr() is C-specific, use index() instead";
}

sub memcmp {
    unimpl "memcmp() is C-specific, use eq instead";
}

sub memcpy {
    unimpl "memcpy() is C-specific, use = instead";
}

sub memmove {
    unimpl "memmove() is C-specific, use = instead";
}

sub memset {
    unimpl "memset() is C-specific, use x instead";
}

sub strcat {
    unimpl "strcat() is C-specific, use .= instead";
}

sub strchr {
    unimpl "strchr() is C-specific, use index() instead";
}

sub strcmp {
    unimpl "strcmp() is C-specific, use eq instead";
}

sub strcpy {
    unimpl "strcpy() is C-specific, use = instead";
}

sub strcspn {
    unimpl "strcspn() is C-specific, use regular expressions instead";
}

sub strerror {
    usage "strerror(errno)" if @_ != 1;
    local $! = $_[0];
    $! . "";
}

sub strlen {
    unimpl "strlen() is C-specific, use length instead";
}

sub strncat {
    unimpl "strncat() is C-specific, use .= instead";
}

sub strncmp {
    unimpl "strncmp() is C-specific, use eq instead";
}

sub strncpy {
    unimpl "strncpy() is C-specific, use = instead";
}

sub strpbrk {
    unimpl "strpbrk() is C-specific, stopped";
}

sub strrchr {
    unimpl "strrchr() is C-specific, use rindex() instead";
}

sub strspn {
    unimpl "strspn() is C-specific, stopped";
}

sub strstr {
    usage "strstr(big, little)" if @_ != 2;
    CORE::index($_[0], $_[1]);
}

sub strtok {
    unimpl "strtok() is C-specific, stopped";
}

sub chmod {
    usage "chmod(mode, filename)" if @_ != 2;
    CORE::chmod($_[0], $_[1]);
}

sub fstat {
    usage "fstat(fd)" if @_ != 1;
    local *TMP;
    CORE::open(TMP, "<&$_[0]");         # Gross.
    my @l = CORE::stat(TMP);
    CORE::close(TMP);
    @l;
}

sub mkdir {
    usage "mkdir(directoryname, mode)" if @_ != 2;
    CORE::mkdir($_[0], $_[1]);
}

sub stat {
    usage "stat(filename)" if @_ != 1;
    CORE::stat($_[0]);
}

sub umask {
    usage "umask(mask)" if @_ != 1;
    CORE::umask($_[0]);
}

sub wait {
    usage "wait()" if @_ != 0;
    CORE::wait();
}

sub waitpid {
    usage "waitpid(pid, options)" if @_ != 2;
    CORE::waitpid($_[0], $_[1]);
}

sub gmtime {
    usage "gmtime(time)" if @_ != 1;
    CORE::gmtime($_[0]);
}

sub localtime {
    usage "localtime(time)" if @_ != 1;
    CORE::localtime($_[0]);
}

sub time {
    usage "time()" if @_ != 0;
    CORE::time;
}

sub alarm {
    usage "alarm(seconds)" if @_ != 1;
    CORE::alarm($_[0]);
}

sub chdir {
    usage "chdir(directory)" if @_ != 1;
    CORE::chdir($_[0]);
}

sub chown {
    usage "chown(uid, gid, filename)" if @_ != 3;
    CORE::chown($_[0], $_[1], $_[2]);
}

sub execl {
    unimpl "execl() is C-specific, stopped";
}

sub execle {
    unimpl "execle() is C-specific, stopped";
}

sub execlp {
    unimpl "execlp() is C-specific, stopped";
}

sub execv {
    unimpl "execv() is C-specific, stopped";
}

sub execve {
    unimpl "execve() is C-specific, stopped";
}

sub execvp {
    unimpl "execvp() is C-specific, stopped";
}

sub fork {
    usage "fork()" if @_ != 0;
    CORE::fork;
}

sub getegid {
    usage "getegid()" if @_ != 0;
    $) + 0;
}

sub geteuid {
    usage "geteuid()" if @_ != 0;
    $> + 0;
}

sub getgid {
    usage "getgid()" if @_ != 0;
    $( + 0;
}

sub getgroups {
    usage "getgroups()" if @_ != 0;
    my %seen;
    grep(!$seen{$_}++, split(' ', $) ));
}

sub getlogin {
    usage "getlogin()" if @_ != 0;
    CORE::getlogin();
}

sub getpgrp {
    usage "getpgrp()" if @_ != 0;
    CORE::getpgrp;
}

sub getpid {
    usage "getpid()" if @_ != 0;
    $$;
}

sub getppid {
    usage "getppid()" if @_ != 0;
    CORE::getppid;
}

sub getuid {
    usage "getuid()" if @_ != 0;
    $<;
}

sub isatty {
    usage "isatty(filehandle)" if @_ != 1;
    -t $_[0];
}

sub link {
    usage "link(oldfilename, newfilename)" if @_ != 2;
    CORE::link($_[0], $_[1]);
}

sub rmdir {
    usage "rmdir(directoryname)" if @_ != 1;
    CORE::rmdir($_[0]);
}

sub setbuf {
    redef "IO::Handle::setbuf()";
}

sub setvbuf {
    redef "IO::Handle::setvbuf()";
}

sub sleep {
    usage "sleep(seconds)" if @_ != 1;
    $_[0] - CORE::sleep($_[0]);
}

sub unlink {
    usage "unlink(filename)" if @_ != 1;
    CORE::unlink($_[0]);
}

sub utime {
    usage "utime(filename, atime, mtime)" if @_ != 3;
    CORE::utime($_[1], $_[2], $_[0]);
}

sub load_imports {
%EXPORT_TAGS = (

    assert_h => [qw(assert NDEBUG)],

    ctype_h =>  [qw(isalnum isalpha iscntrl isdigit isgraph islower
                isprint ispunct isspace isupper isxdigit tolower toupper)],

    dirent_h => [],

    errno_h =>  [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT
                EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED
                ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT
                EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS
                EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK
                EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH
                ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM
                ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR
                ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM
                EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE
                ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT
                ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY
                EUSERS EWOULDBLOCK EXDEV errno)],

    fcntl_h =>  [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK
                F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK
                O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK
                O_RDONLY O_RDWR O_TRUNC O_WRONLY
                creat
                SEEK_CUR SEEK_END SEEK_SET
                S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU
                S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID
                S_IWGRP S_IWOTH S_IWUSR)],

    float_h =>  [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG
                DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP
                DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP
                FLT_DIG FLT_EPSILON FLT_MANT_DIG
                FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP
                FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP
                FLT_RADIX FLT_ROUNDS
                LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG
                LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP
                LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)],

    grp_h =>    [],

    limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX
                INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON
                MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX
                PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN
                SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX
                ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX
                _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT
                _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX
                _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX
                _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)],

    locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES
                    LC_MONETARY LC_NUMERIC LC_TIME NULL
                    localeconv setlocale)],

    math_h =>   [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod
                frexp ldexp log10 modf pow sinh tan tanh)],

    pwd_h =>    [],

    setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)],

    signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK
                SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM
                SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL
                SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN
                SIGTTOU SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR
                SIG_IGN SIG_SETMASK SIG_UNBLOCK raise sigaction signal
                sigpending sigprocmask sigsuspend)],

    stdarg_h => [],

    stddef_h => [qw(NULL offsetof)],

    stdio_h =>  [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid
                L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET
                STREAM_MAX TMP_MAX stderr stdin stdout
                clearerr fclose fdopen feof ferror fflush fgetc fgetpos
                fgets fopen fprintf fputc fputs fread freopen
                fscanf fseek fsetpos ftell fwrite getchar gets
                perror putc putchar puts remove rewind
                scanf setbuf setvbuf sscanf tmpfile tmpnam
                ungetc vfprintf vprintf vsprintf)],

    stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX
                abort atexit atof atoi atol bsearch calloc div
                free getenv labs ldiv malloc mblen mbstowcs mbtowc
                qsort realloc strtod strtol strtoul wcstombs wctomb)],

    string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat
                strchr strcmp strcoll strcpy strcspn strerror strlen
                strncat strncmp strncpy strpbrk strrchr strspn strstr
                strtok strxfrm)],

    sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU
                S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG
                S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR
                fstat mkfifo)],

    sys_times_h => [],

    sys_types_h => [],

    sys_utsname_h => [qw(uname)],

    sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED
                WNOHANG WSTOPSIG WTERMSIG WUNTRACED)],

    termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400
                B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL
                CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK
                ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR
                INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST
                PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION
                TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW
                TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART
                VSTOP VSUSP VTIME
                cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain
                tcflow tcflush tcgetattr tcsendbreak tcsetattr )],

    time_h =>   [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime
                difftime mktime strftime tzset tzname)],

    unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET
                STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK
                _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON
                _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX
                _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED
                _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS
                _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX
                _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL
                _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS
                _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION
                _exit access ctermid cuserid
                dup2 dup execl execle execlp execv execve execvp
                fpathconf fsync getcwd getegid geteuid getgid getgroups
                getpid getuid isatty lseek pathconf pause setgid setpgid
                setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)],

    utime_h =>  [],

);

# Exporter::export_tags();
for (values %EXPORT_TAGS) {
  push @EXPORT, @$_;
}

@EXPORT_OK = qw(
                abs
                alarm
                atan2
                chdir
                chmod
                chown
                close
                closedir
                cos
                exit
                exp
                fcntl
                fileno
                fork
                getc
                getgrgid
                getgrnam
                getlogin
                getpgrp
                getppid
                getpwnam
                getpwuid
                gmtime
                isatty
                kill
                lchown
                link
                localtime
                log
                mkdir
                nice
                open
                opendir
                pipe
                printf
                rand
                read
                readdir
                rename
                rewinddir
                rmdir
                sin
                sleep
                sprintf
                sqrt
                srand
                stat
                system
                time
                times
                umask
                unlink
                utime
                wait
                waitpid
                write
);

require Exporter;
}

package POSIX::SigAction;

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