diff options
Diffstat (limited to 'contrib/perl5/ext/POSIX')
| -rw-r--r-- | contrib/perl5/ext/POSIX/Makefile.PL | 8 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/POSIX.pm | 926 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/POSIX.pod | 1729 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/POSIX.xs | 3666 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/bsdos.pl | 3 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/freebsd.pl | 3 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/linux.pl | 5 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/netbsd.pl | 3 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/next_3.pl | 5 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/openbsd.pl | 3 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/hints/sunos_4.pl | 10 | ||||
| -rw-r--r-- | contrib/perl5/ext/POSIX/typemap | 14 |
12 files changed, 6375 insertions, 0 deletions
diff --git a/contrib/perl5/ext/POSIX/Makefile.PL b/contrib/perl5/ext/POSIX/Makefile.PL new file mode 100644 index 0000000..bc1dda9 --- /dev/null +++ b/contrib/perl5/ext/POSIX/Makefile.PL @@ -0,0 +1,8 @@ +use ExtUtils::MakeMaker; +WriteMakefile( + NAME => 'POSIX', + ($^O eq 'MSWin32' ? () : (LIBS => ["-lm -lposix -lcposix"])), + MAN3PODS => ' ', # Pods will be built by installman. + XSPROTOARG => '-noprototypes', # XXX remove later? + VERSION_FROM => 'POSIX.pm', +); diff --git a/contrib/perl5/ext/POSIX/POSIX.pm b/contrib/perl5/ext/POSIX/POSIX.pm new file mode 100644 index 0000000..5d3ef5c --- /dev/null +++ b/contrib/perl5/ext/POSIX/POSIX.pm @@ -0,0 +1,926 @@ +package POSIX; + +use vars qw($VERSION @ISA %EXPORT_TAGS @EXPORT_OK $AUTOLOAD); + +use Carp; +use AutoLoader; +require Config; +use Symbol; + +require Exporter; +require DynaLoader; +@ISA = qw(Exporter DynaLoader); + +$VERSION = "1.02" ; + +%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 => [qw()], + + 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 => [qw()], + + 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_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 => [qw()], + + 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 => [qw()], + + 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 => [qw()], + + sys_types_h => [qw()], + + 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 + STRERR_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_SAVED_IDS + _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + _exit access ctermid cuserid + dup2 dup execl execle execlp execv execve execvp + fpathconf getcwd getegid geteuid getgid getgroups + getpid getuid isatty lseek pathconf pause setgid setpgid + setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)], + + utime_h => [qw()], + +); + +Exporter::export_tags(); + +@EXPORT_OK = qw( + closedir opendir readdir rewinddir + fcntl open + getgrgid getgrnam + atan2 cos exp log sin sqrt + getpwnam getpwuid + kill + fileno getc printf rename sprintf + abs exit rand srand system + chmod mkdir stat umask + times + wait waitpid + gmtime localtime time + alarm chdir chown close fork getlogin getppid getpgrp link + pipe read rmdir sleep unlink write + utime + nice +); + +# Grandfather old foo_h form to new :foo_h form +sub import { + my $this = shift; + my @list = map { m/^\w+_h$/ ? ":$_" : $_ } @_; + local $Exporter::ExportLevel = 1; + Exporter::import($this,@list); +} + + +bootstrap POSIX $VERSION; + +my $EINVAL = constant("EINVAL", 0); +my $EAGAIN = constant("EAGAIN", 0); + +sub AUTOLOAD { + if ($AUTOLOAD =~ /::(_?[a-z])/) { + $AutoLoader::AUTOLOAD = $AUTOLOAD; + goto &AutoLoader::AUTOLOAD + } + local $! = 0; + my $constname = $AUTOLOAD; + $constname =~ s/.*:://; + my $val = constant($constname, @_ ? $_[0] : 0); + if ($! == 0) { + *$AUTOLOAD = sub { $val }; + } + elsif ($! == $EAGAIN) { # Not really a constant, so always call. + *$AUTOLOAD = sub { constant($constname, $_[0]) }; + } + elsif ($! == $EINVAL) { + croak "$constname is not a valid POSIX macro"; + } + else { + croak "Your vendor has not defined POSIX macro $constname, used"; + } + + goto &$AUTOLOAD; +} + +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"; +} + +############################ +package POSIX::SigAction; + +sub new { + bless {HANDLER => $_[1], MASK => $_[2], FLAGS => $_[3] || 0}, $_[0]; +} + +############################ +package POSIX; # return to package POSIX so AutoSplit is happy +1; +__END__ + +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; + closedir($_[0]); +} + +sub opendir { + usage "opendir(directory)" if @_ != 1; + my $dirhandle = gensym; + opendir($dirhandle, $_[0]) + ? $dirhandle + : undef; +} + +sub readdir { + usage "readdir(dirhandle)" if @_ != 1; + readdir($_[0]); +} + +sub rewinddir { + usage "rewinddir(dirhandle)" if @_ != 1; + 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; + fcntl($_[0], $_[1], $_[2]); +} + +sub getgrgid { + usage "getgrgid(gid)" if @_ != 1; + getgrgid($_[0]); +} + +sub getgrnam { + usage "getgrnam(name)" if @_ != 1; + getgrnam($_[0]); +} + +sub atan2 { + usage "atan2(x,y)" if @_ != 2; + atan2($_[0], $_[1]); +} + +sub cos { + usage "cos(x)" if @_ != 1; + cos($_[0]); +} + +sub exp { + usage "exp(x)" if @_ != 1; + exp($_[0]); +} + +sub fabs { + usage "fabs(x)" if @_ != 1; + abs($_[0]); +} + +sub log { + usage "log(x)" if @_ != 1; + log($_[0]); +} + +sub pow { + usage "pow(x,exponent)" if @_ != 2; + $_[0] ** $_[1]; +} + +sub sin { + usage "sin(x)" if @_ != 1; + sin($_[0]); +} + +sub sqrt { + usage "sqrt(x)" if @_ != 1; + sqrt($_[0]); +} + +sub getpwnam { + usage "getpwnam(name)" if @_ != 1; + getpwnam($_[0]); +} + +sub getpwuid { + usage "getpwuid(uid)" if @_ != 1; + 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; + kill $_[1], $_[0]; +} + +sub raise { + usage "raise(sig)" if @_ != 1; + 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 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; + getc($_[0]); +} + +sub getchar { + usage "getchar()" if @_ != 0; + 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; + 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; + unlink($_[0]); +} + +sub rename { + usage "rename(oldfilename, newfilename)" if @_ != 2; + rename($_[0], $_[1]); +} + +sub rewind { + usage "rewind(filehandle)" if @_ != 1; + seek($_[0],0,0); +} + +sub scanf { + unimpl "scanf() is C-specific--use <> and regular expressions instead"; +} + +sub sprintf { + usage "sprintf(pattern,args)" if @_ == 0; + 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; + 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, stopped"; +} + +sub exit { + usage "exit(status)" if @_ != 1; + 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; + 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; + index($_[0], $_[1]); +} + +sub strtok { + unimpl "strtok() is C-specific, stopped"; +} + +sub chmod { + usage "chmod(mode, filename)" if @_ != 2; + chmod($_[0], $_[1]); +} + +sub fstat { + usage "fstat(fd)" if @_ != 1; + local *TMP; + open(TMP, "<&$_[0]"); # Gross. + my @l = stat(TMP); + close(TMP); + @l; +} + +sub mkdir { + usage "mkdir(directoryname, mode)" if @_ != 2; + mkdir($_[0], $_[1]); +} + +sub stat { + usage "stat(filename)" if @_ != 1; + stat($_[0]); +} + +sub umask { + usage "umask(mask)" if @_ != 1; + umask($_[0]); +} + +sub wait { + usage "wait()" if @_ != 0; + wait(); +} + +sub waitpid { + usage "waitpid(pid, options)" if @_ != 2; + waitpid($_[0], $_[1]); +} + +sub gmtime { + usage "gmtime(time)" if @_ != 1; + gmtime($_[0]); +} + +sub localtime { + usage "localtime(time)" if @_ != 1; + localtime($_[0]); +} + +sub time { + usage "time()" if @_ != 0; + time; +} + +sub alarm { + usage "alarm(seconds)" if @_ != 1; + alarm($_[0]); +} + +sub chdir { + usage "chdir(directory)" if @_ != 1; + chdir($_[0]); +} + +sub chown { + usage "chown(filename, uid, gid)" if @_ != 3; + 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; + fork; +} + +sub getcwd +{ + usage "getcwd()" if @_ != 0; + if ($^O eq 'MSWin32') { + # this perhaps applies to everyone else also? + require Cwd; + $cwd = &Cwd::cwd; + } + else { + chop($cwd = `pwd`); + } + $cwd; +} + +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; + getlogin(); +} + +sub getpgrp { + usage "getpgrp()" if @_ != 0; + getpgrp($_[0]); +} + +sub getpid { + usage "getpid()" if @_ != 0; + $$; +} + +sub getppid { + usage "getppid()" if @_ != 0; + getppid; +} + +sub getuid { + usage "getuid()" if @_ != 0; + $<; +} + +sub isatty { + usage "isatty(filehandle)" if @_ != 1; + -t $_[0]; +} + +sub link { + usage "link(oldfilename, newfilename)" if @_ != 2; + link($_[0], $_[1]); +} + +sub rmdir { + usage "rmdir(directoryname)" if @_ != 1; + rmdir($_[0]); +} + +sub setgid { + usage "setgid(gid)" if @_ != 1; + $( = $_[0]; +} + +sub setuid { + usage "setuid(uid)" if @_ != 1; + $< = $_[0]; +} + +sub sleep { + usage "sleep(seconds)" if @_ != 1; + sleep($_[0]); +} + +sub unlink { + usage "unlink(filename)" if @_ != 1; + unlink($_[0]); +} + +sub utime { + usage "utime(filename, atime, mtime)" if @_ != 3; + utime($_[1], $_[2], $_[0]); +} + diff --git a/contrib/perl5/ext/POSIX/POSIX.pod b/contrib/perl5/ext/POSIX/POSIX.pod new file mode 100644 index 0000000..4726487 --- /dev/null +++ b/contrib/perl5/ext/POSIX/POSIX.pod @@ -0,0 +1,1729 @@ +=head1 NAME + +POSIX - Perl interface to IEEE Std 1003.1 + +=head1 SYNOPSIS + + use POSIX; + use POSIX qw(setsid); + use POSIX qw(:errno_h :fcntl_h); + + printf "EINTR is %d\n", EINTR; + + $sess_id = POSIX::setsid(); + + $fd = POSIX::open($path, O_CREAT|O_EXCL|O_WRONLY, 0644); + # note: that's a filedescriptor, *NOT* a filehandle + +=head1 DESCRIPTION + +The POSIX module permits you to access all (or nearly all) the standard +POSIX 1003.1 identifiers. Many of these identifiers have been given Perl-ish +interfaces. Things which are C<#defines> in C, like EINTR or O_NDELAY, are +automatically exported into your namespace. All functions are only exported +if you ask for them explicitly. Most likely people will prefer to use the +fully-qualified function names. + +This document gives a condensed list of the features available in the POSIX +module. Consult your operating system's manpages for general information on +most features. Consult L<perlfunc> for functions which are noted as being +identical to Perl's builtin functions. + +The first section describes POSIX functions from the 1003.1 specification. +The second section describes some classes for signal objects, TTY objects, +and other miscellaneous objects. The remaining sections list various +constants and macros in an organization which roughly follows IEEE Std +1003.1b-1993. + +=head1 NOTE + +The POSIX module is probably the most complex Perl module supplied with +the standard distribution. It incorporates autoloading, namespace games, +and dynamic loading of code that's in Perl, C, or both. It's a great +source of wisdom. + +=head1 CAVEATS + +A few functions are not implemented because they are C specific. If you +attempt to call these, they will print a message telling you that they +aren't implemented, and suggest using the Perl equivalent should one +exist. For example, trying to access the setjmp() call will elicit the +message "setjmp() is C-specific: use eval {} instead". + +Furthermore, some evil vendors will claim 1003.1 compliance, but in fact +are not so: they will not pass the PCTS (POSIX Compliance Test Suites). +For example, one vendor may not define EDEADLK, or the semantics of the +errno values set by open(2) might not be quite right. Perl does not +attempt to verify POSIX compliance. That means you can currently +successfully say "use POSIX", and then later in your program you find +that your vendor has been lax and there's no usable ICANON macro after +all. This could be construed to be a bug. + +=head1 FUNCTIONS + +=over 8 + +=item _exit + +This is identical to the C function C<_exit()>. + +=item abort + +This is identical to the C function C<abort()>. + +=item abs + +This is identical to Perl's builtin C<abs()> function. + +=item access + +Determines the accessibility of a file. + + if( POSIX::access( "/", &POSIX::R_OK ) ){ + print "have read permission\n"; + } + +Returns C<undef> on failure. + +=item acos + +This is identical to the C function C<acos()>. + +=item alarm + +This is identical to Perl's builtin C<alarm()> function. + +=item asctime + +This is identical to the C function C<asctime()>. + +=item asin + +This is identical to the C function C<asin()>. + +=item assert + +Unimplemented. + +=item atan + +This is identical to the C function C<atan()>. + +=item atan2 + +This is identical to Perl's builtin C<atan2()> function. + +=item atexit + +atexit() is C-specific: use END {} instead. + +=item atof + +atof() is C-specific. + +=item atoi + +atoi() is C-specific. + +=item atol + +atol() is C-specific. + +=item bsearch + +bsearch() not supplied. + +=item calloc + +calloc() is C-specific. + +=item ceil + +This is identical to the C function C<ceil()>. + +=item chdir + +This is identical to Perl's builtin C<chdir()> function. + +=item chmod + +This is identical to Perl's builtin C<chmod()> function. + +=item chown + +This is identical to Perl's builtin C<chown()> function. + +=item clearerr + +Use method C<IO::Handle::clearerr()> instead. + +=item clock + +This is identical to the C function C<clock()>. + +=item close + +Close the file. This uses file descriptors such as those obtained by calling +C<POSIX::open>. + + $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); + POSIX::close( $fd ); + +Returns C<undef> on failure. + +=item closedir + +This is identical to Perl's builtin C<closedir()> function. + +=item cos + +This is identical to Perl's builtin C<cos()> function. + +=item cosh + +This is identical to the C function C<cosh()>. + +=item creat + +Create a new file. This returns a file descriptor like the ones returned by +C<POSIX::open>. Use C<POSIX::close> to close the file. + + $fd = POSIX::creat( "foo", 0611 ); + POSIX::close( $fd ); + +=item ctermid + +Generates the path name for the controlling terminal. + + $path = POSIX::ctermid(); + +=item ctime + +This is identical to the C function C<ctime()>. + +=item cuserid + +Get the character login name of the user. + + $name = POSIX::cuserid(); + +=item difftime + +This is identical to the C function C<difftime()>. + +=item div + +div() is C-specific. + +=item dup + +This is similar to the C function C<dup()>. + +This uses file descriptors such as those obtained by calling +C<POSIX::open>. + +Returns C<undef> on failure. + +=item dup2 + +This is similar to the C function C<dup2()>. + +This uses file descriptors such as those obtained by calling +C<POSIX::open>. + +Returns C<undef> on failure. + +=item errno + +Returns the value of errno. + + $errno = POSIX::errno(); + +=item execl + +execl() is C-specific. + +=item execle + +execle() is C-specific. + +=item execlp + +execlp() is C-specific. + +=item execv + +execv() is C-specific. + +=item execve + +execve() is C-specific. + +=item execvp + +execvp() is C-specific. + +=item exit + +This is identical to Perl's builtin C<exit()> function. + +=item exp + +This is identical to Perl's builtin C<exp()> function. + +=item fabs + +This is identical to Perl's builtin C<abs()> function. + +=item fclose + +Use method C<IO::Handle::close()> instead. + +=item fcntl + +This is identical to Perl's builtin C<fcntl()> function. + +=item fdopen + +Use method C<IO::Handle::new_from_fd()> instead. + +=item feof + +Use method C<IO::Handle::eof()> instead. + +=item ferror + +Use method C<IO::Handle::error()> instead. + +=item fflush + +Use method C<IO::Handle::flush()> instead. + +=item fgetc + +Use method C<IO::Handle::getc()> instead. + +=item fgetpos + +Use method C<IO::Seekable::getpos()> instead. + +=item fgets + +Use method C<IO::Handle::gets()> instead. + +=item fileno + +Use method C<IO::Handle::fileno()> instead. + +=item floor + +This is identical to the C function C<floor()>. + +=item fmod + +This is identical to the C function C<fmod()>. + +=item fopen + +Use method C<IO::File::open()> instead. + +=item fork + +This is identical to Perl's builtin C<fork()> function. + +=item fpathconf + +Retrieves the value of a configurable limit on a file or directory. This +uses file descriptors such as those obtained by calling C<POSIX::open>. + +The following will determine the maximum length of the longest allowable +pathname on the filesystem which holds C</tmp/foo>. + + $fd = POSIX::open( "/tmp/foo", &POSIX::O_RDONLY ); + $path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX ); + +Returns C<undef> on failure. + +=item fprintf + +fprintf() is C-specific--use printf instead. + +=item fputc + +fputc() is C-specific--use print instead. + +=item fputs + +fputs() is C-specific--use print instead. + +=item fread + +fread() is C-specific--use read instead. + +=item free + +free() is C-specific. + +=item freopen + +freopen() is C-specific--use open instead. + +=item frexp + +Return the mantissa and exponent of a floating-point number. + + ($mantissa, $exponent) = POSIX::frexp( 3.14 ); + +=item fscanf + +fscanf() is C-specific--use <> and regular expressions instead. + +=item fseek + +Use method C<IO::Seekable::seek()> instead. + +=item fsetpos + +Use method C<IO::Seekable::setpos()> instead. + +=item fstat + +Get file status. This uses file descriptors such as those obtained by +calling C<POSIX::open>. The data returned is identical to the data from +Perl's builtin C<stat> function. + + $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); + @stats = POSIX::fstat( $fd ); + +=item ftell + +Use method C<IO::Seekable::tell()> instead. + +=item fwrite + +fwrite() is C-specific--use print instead. + +=item getc + +This is identical to Perl's builtin C<getc()> function. + +=item getchar + +Returns one character from STDIN. + +=item getcwd + +Returns the name of the current working directory. + +=item getegid + +Returns the effective group id. + +=item getenv + +Returns the value of the specified enironment variable. + +=item geteuid + +Returns the effective user id. + +=item getgid + +Returns the user's real group id. + +=item getgrgid + +This is identical to Perl's builtin C<getgrgid()> function. + +=item getgrnam + +This is identical to Perl's builtin C<getgrnam()> function. + +=item getgroups + +Returns the ids of the user's supplementary groups. + +=item getlogin + +This is identical to Perl's builtin C<getlogin()> function. + +=item getpgrp + +This is identical to Perl's builtin C<getpgrp()> function. + +=item getpid + +Returns the process's id. + +=item getppid + +This is identical to Perl's builtin C<getppid()> function. + +=item getpwnam + +This is identical to Perl's builtin C<getpwnam()> function. + +=item getpwuid + +This is identical to Perl's builtin C<getpwuid()> function. + +=item gets + +Returns one line from STDIN. + +=item getuid + +Returns the user's id. + +=item gmtime + +This is identical to Perl's builtin C<gmtime()> function. + +=item isalnum + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isalpha + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isatty + +Returns a boolean indicating whether the specified filehandle is connected +to a tty. + +=item iscntrl + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isdigit + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isgraph + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item islower + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isprint + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item ispunct + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isspace + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isupper + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item isxdigit + +This is identical to the C function, except that it can apply to a single +character or to a whole string. + +=item kill + +This is identical to Perl's builtin C<kill()> function. + +=item labs + +labs() is C-specific, use abs instead. + +=item ldexp + +This is identical to the C function C<ldexp()>. + +=item ldiv + +ldiv() is C-specific, use / and int instead. + +=item link + +This is identical to Perl's builtin C<link()> function. + +=item localeconv + +Get numeric formatting information. Returns a reference to a hash +containing the current locale formatting values. + +The database for the B<de> (Deutsch or German) locale. + + $loc = POSIX::setlocale( &POSIX::LC_ALL, "de" ); + print "Locale = $loc\n"; + $lconv = POSIX::localeconv(); + print "decimal_point = ", $lconv->{decimal_point}, "\n"; + print "thousands_sep = ", $lconv->{thousands_sep}, "\n"; + print "grouping = ", $lconv->{grouping}, "\n"; + print "int_curr_symbol = ", $lconv->{int_curr_symbol}, "\n"; + print "currency_symbol = ", $lconv->{currency_symbol}, "\n"; + print "mon_decimal_point = ", $lconv->{mon_decimal_point}, "\n"; + print "mon_thousands_sep = ", $lconv->{mon_thousands_sep}, "\n"; + print "mon_grouping = ", $lconv->{mon_grouping}, "\n"; + print "positive_sign = ", $lconv->{positive_sign}, "\n"; + print "negative_sign = ", $lconv->{negative_sign}, "\n"; + print "int_frac_digits = ", $lconv->{int_frac_digits}, "\n"; + print "frac_digits = ", $lconv->{frac_digits}, "\n"; + print "p_cs_precedes = ", $lconv->{p_cs_precedes}, "\n"; + print "p_sep_by_space = ", $lconv->{p_sep_by_space}, "\n"; + print "n_cs_precedes = ", $lconv->{n_cs_precedes}, "\n"; + print "n_sep_by_space = ", $lconv->{n_sep_by_space}, "\n"; + print "p_sign_posn = ", $lconv->{p_sign_posn}, "\n"; + print "n_sign_posn = ", $lconv->{n_sign_posn}, "\n"; + +=item localtime + +This is identical to Perl's builtin C<localtime()> function. + +=item log + +This is identical to Perl's builtin C<log()> function. + +=item log10 + +This is identical to the C function C<log10()>. + +=item longjmp + +longjmp() is C-specific: use die instead. + +=item lseek + +Move the file's read/write position. This uses file descriptors such as +those obtained by calling C<POSIX::open>. + + $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); + $off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET ); + +Returns C<undef> on failure. + +=item malloc + +malloc() is C-specific. + +=item mblen + +This is identical to the C function C<mblen()>. + +=item mbstowcs + +This is identical to the C function C<mbstowcs()>. + +=item mbtowc + +This is identical to the C function C<mbtowc()>. + +=item memchr + +memchr() is C-specific, use index() instead. + +=item memcmp + +memcmp() is C-specific, use eq instead. + +=item memcpy + +memcpy() is C-specific, use = instead. + +=item memmove + +memmove() is C-specific, use = instead. + +=item memset + +memset() is C-specific, use x instead. + +=item mkdir + +This is identical to Perl's builtin C<mkdir()> function. + +=item mkfifo + +This is similar to the C function C<mkfifo()>. + +Returns C<undef> on failure. + +=item mktime + +Convert date/time info to a calendar time. + +Synopsis: + + mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0) + +The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero. +I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The +year (C<year>) is given in years since 1900. I.e. The year 1995 is 95; the +year 2001 is 101. Consult your system's C<mktime()> manpage for details +about these and the other arguments. + +Calendar time for December 12, 1995, at 10:30 am. + + $time_t = POSIX::mktime( 0, 30, 10, 12, 11, 95 ); + print "Date = ", POSIX::ctime($time_t); + +Returns C<undef> on failure. + +=item modf + +Return the integral and fractional parts of a floating-point number. + + ($fractional, $integral) = POSIX::modf( 3.14 ); + +=item nice + +This is similar to the C function C<nice()>. + +Returns C<undef> on failure. + +=item offsetof + +offsetof() is C-specific. + +=item open + +Open a file for reading for writing. This returns file descriptors, not +Perl filehandles. Use C<POSIX::close> to close the file. + +Open a file read-only with mode 0666. + + $fd = POSIX::open( "foo" ); + +Open a file for read and write. + + $fd = POSIX::open( "foo", &POSIX::O_RDWR ); + +Open a file for write, with truncation. + + $fd = POSIX::open( "foo", &POSIX::O_WRONLY | &POSIX::O_TRUNC ); + +Create a new file with mode 0640. Set up the file for writing. + + $fd = POSIX::open( "foo", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640 ); + +Returns C<undef> on failure. + +=item opendir + +Open a directory for reading. + + $dir = POSIX::opendir( "/tmp" ); + @files = POSIX::readdir( $dir ); + POSIX::closedir( $dir ); + +Returns C<undef> on failure. + +=item pathconf + +Retrieves the value of a configurable limit on a file or directory. + +The following will determine the maximum length of the longest allowable +pathname on the filesystem which holds C</tmp>. + + $path_max = POSIX::pathconf( "/tmp", &POSIX::_PC_PATH_MAX ); + +Returns C<undef> on failure. + +=item pause + +This is similar to the C function C<pause()>. + +Returns C<undef> on failure. + +=item perror + +This is identical to the C function C<perror()>. + +=item pipe + +Create an interprocess channel. This returns file descriptors like those +returned by C<POSIX::open>. + + ($fd0, $fd1) = POSIX::pipe(); + POSIX::write( $fd0, "hello", 5 ); + POSIX::read( $fd1, $buf, 5 ); + +=item pow + +Computes $x raised to the power $exponent. + + $ret = POSIX::pow( $x, $exponent ); + +=item printf + +Prints the specified arguments to STDOUT. + +=item putc + +putc() is C-specific--use print instead. + +=item putchar + +putchar() is C-specific--use print instead. + +=item puts + +puts() is C-specific--use print instead. + +=item qsort + +qsort() is C-specific, use sort instead. + +=item raise + +Sends the specified signal to the current process. + +=item rand + +rand() is non-portable, use Perl's rand instead. + +=item read + +Read from a file. This uses file descriptors such as those obtained by +calling C<POSIX::open>. If the buffer C<$buf> is not large enough for the +read then Perl will extend it to make room for the request. + + $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); + $bytes = POSIX::read( $fd, $buf, 3 ); + +Returns C<undef> on failure. + +=item readdir + +This is identical to Perl's builtin C<readdir()> function. + +=item realloc + +realloc() is C-specific. + +=item remove + +This is identical to Perl's builtin C<unlink()> function. + +=item rename + +This is identical to Perl's builtin C<rename()> function. + +=item rewind + +Seeks to the beginning of the file. + +=item rewinddir + +This is identical to Perl's builtin C<rewinddir()> function. + +=item rmdir + +This is identical to Perl's builtin C<rmdir()> function. + +=item scanf + +scanf() is C-specific--use <> and regular expressions instead. + +=item setgid + +Sets the real group id for this process. + +=item setjmp + +setjmp() is C-specific: use eval {} instead. + +=item setlocale + +Modifies and queries program's locale. + +The following will set the traditional UNIX system locale behavior +(the second argument C<"C">). + + $loc = POSIX::setlocale( &POSIX::LC_ALL, "C" ); + +The following will query (the missing second argument) the current +LC_CTYPE category. + + $loc = POSIX::setlocale( &POSIX::LC_CTYPE); + +The following will set the LC_CTYPE behaviour according to the locale +environment variables (the second argument C<"">). +Please see your systems L<setlocale(3)> documentation for the locale +environment variables' meaning or consult L<perllocale>. + + $loc = POSIX::setlocale( &POSIX::LC_CTYPE, ""); + +The following will set the LC_COLLATE behaviour to Argentinian +Spanish. B<NOTE>: The naming and availability of locales depends on +your operating system. Please consult L<perllocale> for how to find +out which locales are available in your system. + + $loc = POSIX::setlocale( &POSIX::LC_ALL, "es_AR.ISO8859-1" ); + +=item setpgid + +This is similar to the C function C<setpgid()>. + +Returns C<undef> on failure. + +=item setsid + +This is identical to the C function C<setsid()>. + +=item setuid + +Sets the real user id for this process. + +=item sigaction + +Detailed signal management. This uses C<POSIX::SigAction> objects for the +C<action> and C<oldaction> arguments. Consult your system's C<sigaction> +manpage for details. + +Synopsis: + + sigaction(sig, action, oldaction = 0) + +Returns C<undef> on failure. + +=item siglongjmp + +siglongjmp() is C-specific: use die instead. + +=item sigpending + +Examine signals that are blocked and pending. This uses C<POSIX::SigSet> +objects for the C<sigset> argument. Consult your system's C<sigpending> +manpage for details. + +Synopsis: + + sigpending(sigset) + +Returns C<undef> on failure. + +=item sigprocmask + +Change and/or examine calling process's signal mask. This uses +C<POSIX::SigSet> objects for the C<sigset> and C<oldsigset> arguments. +Consult your system's C<sigprocmask> manpage for details. + +Synopsis: + + sigprocmask(how, sigset, oldsigset = 0) + +Returns C<undef> on failure. + +=item sigsetjmp + +sigsetjmp() is C-specific: use eval {} instead. + +=item sigsuspend + +Install a signal mask and suspend process until signal arrives. This uses +C<POSIX::SigSet> objects for the C<signal_mask> argument. Consult your +system's C<sigsuspend> manpage for details. + +Synopsis: + + sigsuspend(signal_mask) + +Returns C<undef> on failure. + +=item sin + +This is identical to Perl's builtin C<sin()> function. + +=item sinh + +This is identical to the C function C<sinh()>. + +=item sleep + +This is identical to Perl's builtin C<sleep()> function. + +=item sprintf + +This is identical to Perl's builtin C<sprintf()> function. + +=item sqrt + +This is identical to Perl's builtin C<sqrt()> function. + +=item srand + +srand(). + +=item sscanf + +sscanf() is C-specific--use regular expressions instead. + +=item stat + +This is identical to Perl's builtin C<stat()> function. + +=item strcat + +strcat() is C-specific, use .= instead. + +=item strchr + +strchr() is C-specific, use index() instead. + +=item strcmp + +strcmp() is C-specific, use eq instead. + +=item strcoll + +This is identical to the C function C<strcoll()>. + +=item strcpy + +strcpy() is C-specific, use = instead. + +=item strcspn + +strcspn() is C-specific, use regular expressions instead. + +=item strerror + +Returns the error string for the specified errno. + +=item strftime + +Convert date and time information to string. Returns the string. + +Synopsis: + + strftime(fmt, sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0) + +The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero. +I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The +year (C<year>) is given in years since 1900. I.e. The year 1995 is 95; the +year 2001 is 101. Consult your system's C<strftime()> manpage for details +about these and the other arguments. + +The string for Tuesday, December 12, 1995. + + $str = POSIX::strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 ); + print "$str\n"; + +=item strlen + +strlen() is C-specific, use length instead. + +=item strncat + +strncat() is C-specific, use .= instead. + +=item strncmp + +strncmp() is C-specific, use eq instead. + +=item strncpy + +strncpy() is C-specific, use = instead. + +=item stroul + +stroul() is C-specific. + +=item strpbrk + +strpbrk() is C-specific. + +=item strrchr + +strrchr() is C-specific, use rindex() instead. + +=item strspn + +strspn() is C-specific. + +=item strstr + +This is identical to Perl's builtin C<index()> function. + +=item strtod + +String to double translation. Returns the parsed number and the number +of characters in the unparsed portion of the string. Truly +POSIX-compliant systems set $! ($ERRNO) to indicate a translation +error, so clear $! before calling strtod. However, non-POSIX systems +may not check for overflow, and therefore will never set $!. + +strtod should respect any POSIX I<setlocale()> settings. + +To parse a string $str as a floating point number use + + $! = 0; + ($num, $n_unparsed) = POSIX::strtod($str); + +The second returned item and $! can be used to check for valid input: + + if (($str eq '') || ($n_unparsed != 0) || !$!) { + die "Non-numeric input $str" . $! ? ": $!\n" : "\n"; + } + +When called in a scalar context strtod returns the parsed number. + +=item strtok + +strtok() is C-specific. + +=item strtol + +String to (long) integer translation. Returns the parsed number and +the number of characters in the unparsed portion of the string. Truly +POSIX-compliant systems set $! ($ERRNO) to indicate a translation +error, so clear $! before calling strtol. However, non-POSIX systems +may not check for overflow, and therefore will never set $!. + +strtol should respect any POSIX I<setlocale()> settings. + +To parse a string $str as a number in some base $base use + + $! = 0; + ($num, $n_unparsed) = POSIX::strtol($str, $base); + +The base should be zero or between 2 and 36, inclusive. When the base +is zero or omitted strtol will use the string itself to determine the +base: a leading "0x" or "0X" means hexadecimal; a leading "0" means +octal; any other leading characters mean decimal. Thus, "1234" is +parsed as a decimal number, "01234" as an octal number, and "0x1234" +as a hexadecimal number. + +The second returned item and $! can be used to check for valid input: + + if (($str eq '') || ($n_unparsed != 0) || !$!) { + die "Non-numeric input $str" . $! ? ": $!\n" : "\n"; + } + +When called in a scalar context strtol returns the parsed number. + +=item strtoul + +String to unsigned (long) integer translation. strtoul is identical +to strtol except that strtoul only parses unsigned integers. See +I<strtol> for details. + +Note: Some vendors supply strtod and strtol but not strtoul. +Other vendors that do suply strtoul parse "-1" as a valid value. + +=item strxfrm + +String transformation. Returns the transformed string. + + $dst = POSIX::strxfrm( $src ); + +=item sysconf + +Retrieves values of system configurable variables. + +The following will get the machine's clock speed. + + $clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK ); + +Returns C<undef> on failure. + +=item system + +This is identical to Perl's builtin C<system()> function. + +=item tan + +This is identical to the C function C<tan()>. + +=item tanh + +This is identical to the C function C<tanh()>. + +=item tcdrain + +This is similar to the C function C<tcdrain()>. + +Returns C<undef> on failure. + +=item tcflow + +This is similar to the C function C<tcflow()>. + +Returns C<undef> on failure. + +=item tcflush + +This is similar to the C function C<tcflush()>. + +Returns C<undef> on failure. + +=item tcgetpgrp + +This is identical to the C function C<tcgetpgrp()>. + +=item tcsendbreak + +This is similar to the C function C<tcsendbreak()>. + +Returns C<undef> on failure. + +=item tcsetpgrp + +This is similar to the C function C<tcsetpgrp()>. + +Returns C<undef> on failure. + +=item time + +This is identical to Perl's builtin C<time()> function. + +=item times + +The times() function returns elapsed realtime since some point in the past +(such as system startup), user and system times for this process, and user +and system times used by child processes. All times are returned in clock +ticks. + + ($realtime, $user, $system, $cuser, $csystem) = POSIX::times(); + +Note: Perl's builtin C<times()> function returns four values, measured in +seconds. + +=item tmpfile + +Use method C<IO::File::new_tmpfile()> instead. + +=item tmpnam + +Returns a name for a temporary file. + + $tmpfile = POSIX::tmpnam(); + +=item tolower + +This is identical to Perl's builtin C<lc()> function. + +=item toupper + +This is identical to Perl's builtin C<uc()> function. + +=item ttyname + +This is identical to the C function C<ttyname()>. + +=item tzname + +Retrieves the time conversion information from the C<tzname> variable. + + POSIX::tzset(); + ($std, $dst) = POSIX::tzname(); + +=item tzset + +This is identical to the C function C<tzset()>. + +=item umask + +This is identical to Perl's builtin C<umask()> function. + +=item uname + +Get name of current operating system. + + ($sysname, $nodename, $release, $version, $machine ) = POSIX::uname(); + +=item ungetc + +Use method C<IO::Handle::ungetc()> instead. + +=item unlink + +This is identical to Perl's builtin C<unlink()> function. + +=item utime + +This is identical to Perl's builtin C<utime()> function. + +=item vfprintf + +vfprintf() is C-specific. + +=item vprintf + +vprintf() is C-specific. + +=item vsprintf + +vsprintf() is C-specific. + +=item wait + +This is identical to Perl's builtin C<wait()> function. + +=item waitpid + +Wait for a child process to change state. This is identical to Perl's +builtin C<waitpid()> function. + + $pid = POSIX::waitpid( -1, &POSIX::WNOHANG ); + print "status = ", ($? / 256), "\n"; + +=item wcstombs + +This is identical to the C function C<wcstombs()>. + +=item wctomb + +This is identical to the C function C<wctomb()>. + +=item write + +Write to a file. This uses file descriptors such as those obtained by +calling C<POSIX::open>. + + $fd = POSIX::open( "foo", &POSIX::O_WRONLY ); + $buf = "hello"; + $bytes = POSIX::write( $b, $buf, 5 ); + +Returns C<undef> on failure. + +=back + +=head1 CLASSES + +=head2 POSIX::SigAction + +=over 8 + +=item new + +Creates a new C<POSIX::SigAction> object which corresponds to the C +C<struct sigaction>. This object will be destroyed automatically when it is +no longer needed. The first parameter is the fully-qualified name of a sub +which is a signal-handler. The second parameter is a C<POSIX::SigSet> +object, it defaults to the empty set. The third parameter contains the +C<sa_flags>, it defaults to 0. + + $sigset = POSIX::SigSet->new(SIGINT, SIGQUIT); + $sigaction = POSIX::SigAction->new( 'main::handler', $sigset, &POSIX::SA_NOCLDSTOP ); + +This C<POSIX::SigAction> object should be used with the C<POSIX::sigaction()> +function. + +=back + +=head2 POSIX::SigSet + +=over 8 + +=item new + +Create a new SigSet object. This object will be destroyed automatically +when it is no longer needed. Arguments may be supplied to initialize the +set. + +Create an empty set. + + $sigset = POSIX::SigSet->new; + +Create a set with SIGUSR1. + + $sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 ); + +=item addset + +Add a signal to a SigSet object. + + $sigset->addset( &POSIX::SIGUSR2 ); + +Returns C<undef> on failure. + +=item delset + +Remove a signal from the SigSet object. + + $sigset->delset( &POSIX::SIGUSR2 ); + +Returns C<undef> on failure. + +=item emptyset + +Initialize the SigSet object to be empty. + + $sigset->emptyset(); + +Returns C<undef> on failure. + +=item fillset + +Initialize the SigSet object to include all signals. + + $sigset->fillset(); + +Returns C<undef> on failure. + +=item ismember + +Tests the SigSet object to see if it contains a specific signal. + + if( $sigset->ismember( &POSIX::SIGUSR1 ) ){ + print "contains SIGUSR1\n"; + } + +=back + +=head2 POSIX::Termios + +=over 8 + +=item new + +Create a new Termios object. This object will be destroyed automatically +when it is no longer needed. A Termios object corresponds to the termios +C struct. new() mallocs a new one, getattr() fills it from a file descriptor, +and setattr() sets a file descriptor's parameters to match Termios' contents. + + $termios = POSIX::Termios->new; + +=item getattr + +Get terminal control attributes. + +Obtain the attributes for stdin. + + $termios->getattr() + +Obtain the attributes for stdout. + + $termios->getattr( 1 ) + +Returns C<undef> on failure. + +=item getcc + +Retrieve a value from the c_cc field of a termios object. The c_cc field is +an array so an index must be specified. + + $c_cc[1] = $termios->getcc(1); + +=item getcflag + +Retrieve the c_cflag field of a termios object. + + $c_cflag = $termios->getcflag; + +=item getiflag + +Retrieve the c_iflag field of a termios object. + + $c_iflag = $termios->getiflag; + +=item getispeed + +Retrieve the input baud rate. + + $ispeed = $termios->getispeed; + +=item getlflag + +Retrieve the c_lflag field of a termios object. + + $c_lflag = $termios->getlflag; + +=item getoflag + +Retrieve the c_oflag field of a termios object. + + $c_oflag = $termios->getoflag; + +=item getospeed + +Retrieve the output baud rate. + + $ospeed = $termios->getospeed; + +=item setattr + +Set terminal control attributes. + +Set attributes immediately for stdout. + + $termios->setattr( 1, &POSIX::TCSANOW ); + +Returns C<undef> on failure. + +=item setcc + +Set a value in the c_cc field of a termios object. The c_cc field is an +array so an index must be specified. + + $termios->setcc( &POSIX::VEOF, 1 ); + +=item setcflag + +Set the c_cflag field of a termios object. + + $termios->setcflag( $c_cflag | &POSIX::CLOCAL ); + +=item setiflag + +Set the c_iflag field of a termios object. + + $termios->setiflag( $c_iflag | &POSIX::BRKINT ); + +=item setispeed + +Set the input baud rate. + + $termios->setispeed( &POSIX::B9600 ); + +Returns C<undef> on failure. + +=item setlflag + +Set the c_lflag field of a termios object. + + $termios->setlflag( $c_lflag | &POSIX::ECHO ); + +=item setoflag + +Set the c_oflag field of a termios object. + + $termios->setoflag( $c_oflag | &POSIX::OPOST ); + +=item setospeed + +Set the output baud rate. + + $termios->setospeed( &POSIX::B9600 ); + +Returns C<undef> on failure. + +=item Baud rate values + +B38400 B75 B200 B134 B300 B1800 B150 B0 B19200 B1200 B9600 B600 B4800 B50 B2400 B110 + +=item Terminal interface values + +TCSADRAIN TCSANOW TCOON TCIOFLUSH TCOFLUSH TCION TCIFLUSH TCSAFLUSH TCIOFF TCOOFF + +=item c_cc field values + +VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS + +=item c_cflag field values + +CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD + +=item c_iflag field values + +BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK + +=item c_lflag field values + +ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP + +=item c_oflag field values + +OPOST + +=back + +=head1 PATHNAME CONSTANTS + +=over 8 + +=item Constants + +_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 + +=back + +=head1 POSIX CONSTANTS + +=over 8 + +=item Constants + +_POSIX_ARG_MAX _POSIX_CHILD_MAX _POSIX_CHOWN_RESTRICTED _POSIX_JOB_CONTROL _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_NO_TRUNC _POSIX_OPEN_MAX _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SAVED_IDS _POSIX_SSIZE_MAX _POSIX_STREAM_MAX _POSIX_TZNAME_MAX _POSIX_VDISABLE _POSIX_VERSION + +=back + +=head1 SYSTEM CONFIGURATION + +=over 8 + +=item Constants + +_SC_ARG_MAX _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_SAVED_IDS _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + +=back + +=head1 ERRNO + +=over 8 + +=item Constants + +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 + +=back + +=head1 FCNTL + +=over 8 + +=item Constants + +FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_OK 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 + +=back + +=head1 FLOAT + +=over 8 + +=item Constants + +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 + +=back + +=head1 LIMITS + +=over 8 + +=item Constants + +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 + +=back + +=head1 LOCALE + +=over 8 + +=item Constants + +LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME + +=back + +=head1 MATH + +=over 8 + +=item Constants + +HUGE_VAL + +=back + +=head1 SIGNAL + +=over 8 + +=item Constants + +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 + +=back + +=head1 STAT + +=over 8 + +=item Constants + +S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + +=item Macros + +S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG + +=back + +=head1 STDLIB + +=over 8 + +=item Constants + +EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX RAND_MAX + +=back + +=head1 STDIO + +=over 8 + +=item Constants + +BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid L_tmpname TMP_MAX + +=back + +=head1 TIME + +=over 8 + +=item Constants + +CLK_TCK CLOCKS_PER_SEC + +=back + +=head1 UNISTD + +=over 8 + +=item Constants + +R_OK SEEK_CUR SEEK_END SEEK_SET STDIN_FILENO STDOUT_FILENO STRERR_FILENO W_OK X_OK + +=back + +=head1 WAIT + +=over 8 + +=item Constants + +WNOHANG WUNTRACED + +=item Macros + +WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG + +=back + +=head1 CREATION + +This document generated by ./mkposixman.PL version 19960129. + diff --git a/contrib/perl5/ext/POSIX/POSIX.xs b/contrib/perl5/ext/POSIX/POSIX.xs new file mode 100644 index 0000000..6958c00 --- /dev/null +++ b/contrib/perl5/ext/POSIX/POSIX.xs @@ -0,0 +1,3666 @@ +#ifdef WIN32 +#define _POSIX_ +#endif +#include "EXTERN.h" +#define PERLIO_NOT_STDIO 1 +#include "perl.h" +#include "XSUB.h" +#ifdef PERL_OBJECT /* XXX _very_ temporary hacks */ +# undef signal +# undef open +# undef setmode +# define open PerlLIO_open3 +# undef TAINT_PROPER +# define TAINT_PROPER(a) +#endif +#include <ctype.h> +#ifdef I_DIRENT /* XXX maybe better to just rely on perl.h? */ +#include <dirent.h> +#endif +#include <errno.h> +#ifdef I_FLOAT +#include <float.h> +#endif +#ifdef I_LIMITS +#include <limits.h> +#endif +#include <locale.h> +#include <math.h> +#ifdef I_PWD +#include <pwd.h> +#endif +#include <setjmp.h> +#include <signal.h> +#include <stdarg.h> + +#ifdef I_STDDEF +#include <stddef.h> +#endif + +/* XXX This comment is just to make I_TERMIO and I_SGTTY visible to + metaconfig for future extension writers. We don't use them in POSIX. + (This is really sneaky :-) --AD +*/ +#if defined(I_TERMIOS) +#include <termios.h> +#endif +#ifdef I_STDLIB +#include <stdlib.h> +#endif +#include <string.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <time.h> +#ifdef I_UNISTD +#include <unistd.h> +#endif +#include <fcntl.h> + +#if defined(__VMS) && !defined(__POSIX_SOURCE) +# include <libdef.h> /* LIB$_INVARG constant */ +# include <lib$routines.h> /* prototype for lib$ediv() */ +# include <starlet.h> /* prototype for sys$gettim() */ +# if DECC_VERSION < 50000000 +# define pid_t int /* old versions of DECC miss this in types.h */ +# endif + +# undef mkfifo +# define mkfifo(a,b) (not_here("mkfifo"),-1) +# define tzset() not_here("tzset") + +#if ((__VMS_VER >= 70000000) && (__DECC_VER >= 50200000)) || (__CRTL_VER >= 70000000) +# define HAS_TZNAME /* shows up in VMS 7.0 or Dec C 5.6 */ +# include <utsname.h> +# endif /* __VMS_VER >= 70000000 or Dec C 5.6 */ + + /* The POSIX notion of ttyname() is better served by getname() under VMS */ + static char ttnambuf[64]; +# define ttyname(fd) (isatty(fd) > 0 ? getname(fd,ttnambuf,0) : NULL) + + /* The non-POSIX CRTL times() has void return type, so we just get the + current time directly */ + clock_t vms_times(struct tms *PL_bufptr) { + clock_t retval; + /* Get wall time and convert to 10 ms intervals to + * produce the return value that the POSIX standard expects */ +# if defined(__DECC) && defined (__ALPHA) +# include <ints.h> + uint64 vmstime; + _ckvmssts(sys$gettim(&vmstime)); + vmstime /= 100000; + retval = vmstime & 0x7fffffff; +# else + /* (Older hw or ccs don't have an atomic 64-bit type, so we + * juggle 32-bit ints (and a float) to produce a time_t result + * with minimal loss of information.) */ + long int vmstime[2],remainder,divisor = 100000; + _ckvmssts(sys$gettim((unsigned long int *)vmstime)); + vmstime[1] &= 0x7fff; /* prevent overflow in EDIV */ + _ckvmssts(lib$ediv(&divisor,vmstime,(long int *)&retval,&remainder)); +# endif + /* Fill in the struct tms using the CRTL routine . . .*/ + times((tbuffer_t *)PL_bufptr); + return (clock_t) retval; + } +# define times(t) vms_times(t) +#else +#if defined (WIN32) +# undef mkfifo +# define mkfifo(a,b) not_here("mkfifo") +# define ttyname(a) (char*)not_here("ttyname") +# define sigset_t long +# define pid_t long +# ifdef __BORLANDC__ +# define tzname _tzname +# endif +# ifdef _MSC_VER +# define mode_t short +# endif +# ifdef __MINGW32__ +# define mode_t short +# ifndef tzset +# define tzset() not_here("tzset") +# endif +# ifndef _POSIX_OPEN_MAX +# define _POSIX_OPEN_MAX FOPEN_MAX /* XXX bogus ? */ +# endif +# endif +# define sigaction(a,b,c) not_here("sigaction") +# define sigpending(a) not_here("sigpending") +# define sigprocmask(a,b,c) not_here("sigprocmask") +# define sigsuspend(a) not_here("sigsuspend") +# define sigemptyset(a) not_here("sigemptyset") +# define sigaddset(a,b) not_here("sigaddset") +# define sigdelset(a,b) not_here("sigdelset") +# define sigfillset(a) not_here("sigfillset") +# define sigismember(a,b) not_here("sigismember") +#else + +# ifndef HAS_MKFIFO +# ifndef mkfifo +# define mkfifo(path, mode) (mknod((path), (mode) | S_IFIFO, 0)) +# endif +# endif /* !HAS_MKFIFO */ + +# include <grp.h> +# include <sys/times.h> +# ifdef HAS_UNAME +# include <sys/utsname.h> +# endif +# include <sys/wait.h> +# ifdef I_UTIME +# include <utime.h> +# endif +#endif /* WIN32 */ +#endif /* __VMS */ + +typedef int SysRet; +typedef long SysRetLong; +typedef sigset_t* POSIX__SigSet; +typedef HV* POSIX__SigAction; +#ifdef I_TERMIOS +typedef struct termios* POSIX__Termios; +#else /* Define termios types to int, and call not_here for the functions.*/ +#define POSIX__Termios int +#define speed_t int +#define tcflag_t int +#define cc_t int +#define cfgetispeed(x) not_here("cfgetispeed") +#define cfgetospeed(x) not_here("cfgetospeed") +#define tcdrain(x) not_here("tcdrain") +#define tcflush(x,y) not_here("tcflush") +#define tcsendbreak(x,y) not_here("tcsendbreak") +#define cfsetispeed(x,y) not_here("cfsetispeed") +#define cfsetospeed(x,y) not_here("cfsetospeed") +#define ctermid(x) (char *) not_here("ctermid") +#define tcflow(x,y) not_here("tcflow") +#define tcgetattr(x,y) not_here("tcgetattr") +#define tcsetattr(x,y,z) not_here("tcsetattr") +#endif + +/* Possibly needed prototypes */ +char *cuserid _((char *)); +double strtod _((const char *, char **)); +long strtol _((const char *, char **, int)); +unsigned long strtoul _((const char *, char **, int)); + +#ifndef HAS_CUSERID +#define cuserid(a) (char *) not_here("cuserid") +#endif +#ifndef HAS_DIFFTIME +#ifndef difftime +#define difftime(a,b) not_here("difftime") +#endif +#endif +#ifndef HAS_FPATHCONF +#define fpathconf(f,n) (SysRetLong) not_here("fpathconf") +#endif +#ifndef HAS_MKTIME +#define mktime(a) not_here("mktime") +#endif +#ifndef HAS_NICE +#define nice(a) not_here("nice") +#endif +#ifndef HAS_PATHCONF +#define pathconf(f,n) (SysRetLong) not_here("pathconf") +#endif +#ifndef HAS_SYSCONF +#define sysconf(n) (SysRetLong) not_here("sysconf") +#endif +#ifndef HAS_READLINK +#define readlink(a,b,c) not_here("readlink") +#endif +#ifndef HAS_SETPGID +#define setpgid(a,b) not_here("setpgid") +#endif +#ifndef HAS_SETSID +#define setsid() not_here("setsid") +#endif +#ifndef HAS_STRCOLL +#define strcoll(s1,s2) not_here("strcoll") +#endif +#ifndef HAS_STRTOD +#define strtod(s1,s2) not_here("strtod") +#endif +#ifndef HAS_STRTOL +#define strtol(s1,s2,b) not_here("strtol") +#endif +#ifndef HAS_STRTOUL +#define strtoul(s1,s2,b) not_here("strtoul") +#endif +#ifndef HAS_STRXFRM +#define strxfrm(s1,s2,n) not_here("strxfrm") +#endif +#ifndef HAS_TCGETPGRP +#define tcgetpgrp(a) not_here("tcgetpgrp") +#endif +#ifndef HAS_TCSETPGRP +#define tcsetpgrp(a,b) not_here("tcsetpgrp") +#endif +#ifndef HAS_TIMES +#define times(a) not_here("times") +#endif +#ifndef HAS_UNAME +#define uname(a) not_here("uname") +#endif +#ifndef HAS_WAITPID +#define waitpid(a,b,c) not_here("waitpid") +#endif + +#ifndef HAS_MBLEN +#ifndef mblen +#define mblen(a,b) not_here("mblen") +#endif +#endif +#ifndef HAS_MBSTOWCS +#define mbstowcs(s, pwcs, n) not_here("mbstowcs") +#endif +#ifndef HAS_MBTOWC +#define mbtowc(pwc, s, n) not_here("mbtowc") +#endif +#ifndef HAS_WCSTOMBS +#define wcstombs(s, pwcs, n) not_here("wcstombs") +#endif +#ifndef HAS_WCTOMB +#define wctomb(s, wchar) not_here("wcstombs") +#endif +#if !defined(HAS_MBLEN) && !defined(HAS_MBSTOWCS) && !defined(HAS_MBTOWC) && !defined(HAS_WCSTOMBS) && !defined(HAS_WCTOMB) +/* If we don't have these functions, then we wouldn't have gotten a typedef + for wchar_t, the wide character type. Defining wchar_t allows the + functions referencing it to compile. Its actual type is then meaningless, + since without the above functions, all sections using it end up calling + not_here() and croak. --Kaveh Ghazi (ghazi@noc.rutgers.edu) 9/18/94. */ +#ifndef wchar_t +#define wchar_t char +#endif +#endif + +#ifndef HAS_LOCALECONV +#define localeconv() not_here("localeconv") +#endif + +#ifdef HAS_TZNAME +# ifndef WIN32 +extern char *tzname[]; +# endif +#else +#if !defined(WIN32) || (defined(__MINGW32__) && !defined(tzname)) +char *tzname[] = { "" , "" }; +#endif +#endif + +/* XXX struct tm on some systems (SunOS4/BSD) contains extra (non POSIX) + * fields for which we don't have Configure support yet: + * char *tm_zone; -- abbreviation of timezone name + * long tm_gmtoff; -- offset from GMT in seconds + * To workaround core dumps from the uninitialised tm_zone we get the + * system to give us a reasonable struct to copy. This fix means that + * strftime uses the tm_zone and tm_gmtoff values returned by + * localtime(time()). That should give the desired result most of the + * time. But probably not always! + * + * This is a temporary workaround to be removed once Configure + * support is added and NETaa14816 is considered in full. + * It does not address tzname aspects of NETaa14816. + */ +#ifdef HAS_GNULIBC +# ifndef STRUCT_TM_HASZONE +# define STRUCT_TM_HAS_ZONE +# endif +#endif + +#ifdef STRUCT_TM_HASZONE +static void +init_tm(ptm) /* see mktime, strftime and asctime */ + struct tm *ptm; +{ + Time_t now; + (void)time(&now); + Copy(localtime(&now), ptm, 1, struct tm); +} + +#else +# define init_tm(ptm) +#endif + + +#ifdef HAS_LONG_DOUBLE +# if LONG_DOUBLESIZE > DOUBLESIZE +# undef HAS_LONG_DOUBLE /* XXX until we figure out how to use them */ +# endif +#endif + +#ifndef HAS_LONG_DOUBLE +#ifdef LDBL_MAX +#undef LDBL_MAX +#endif +#ifdef LDBL_MIN +#undef LDBL_MIN +#endif +#ifdef LDBL_EPSILON +#undef LDBL_EPSILON +#endif +#endif + +static int +not_here(char *s) +{ + croak("POSIX::%s not implemented on this architecture", s); + return -1; +} + +static +#ifdef HAS_LONG_DOUBLE +long double +#else +double +#endif +constant(char *name, int arg) +{ + errno = 0; + switch (*name) { + case 'A': + if (strEQ(name, "ARG_MAX")) +#ifdef ARG_MAX + return ARG_MAX; +#else + goto not_there; +#endif + break; + case 'B': + if (strEQ(name, "BUFSIZ")) +#ifdef BUFSIZ + return BUFSIZ; +#else + goto not_there; +#endif + if (strEQ(name, "BRKINT")) +#ifdef BRKINT + return BRKINT; +#else + goto not_there; +#endif + if (strEQ(name, "B9600")) +#ifdef B9600 + return B9600; +#else + goto not_there; +#endif + if (strEQ(name, "B19200")) +#ifdef B19200 + return B19200; +#else + goto not_there; +#endif + if (strEQ(name, "B38400")) +#ifdef B38400 + return B38400; +#else + goto not_there; +#endif + if (strEQ(name, "B0")) +#ifdef B0 + return B0; +#else + goto not_there; +#endif + if (strEQ(name, "B110")) +#ifdef B110 + return B110; +#else + goto not_there; +#endif + if (strEQ(name, "B1200")) +#ifdef B1200 + return B1200; +#else + goto not_there; +#endif + if (strEQ(name, "B134")) +#ifdef B134 + return B134; +#else + goto not_there; +#endif + if (strEQ(name, "B150")) +#ifdef B150 + return B150; +#else + goto not_there; +#endif + if (strEQ(name, "B1800")) +#ifdef B1800 + return B1800; +#else + goto not_there; +#endif + if (strEQ(name, "B200")) +#ifdef B200 + return B200; +#else + goto not_there; +#endif + if (strEQ(name, "B2400")) +#ifdef B2400 + return B2400; +#else + goto not_there; +#endif + if (strEQ(name, "B300")) +#ifdef B300 + return B300; +#else + goto not_there; +#endif + if (strEQ(name, "B4800")) +#ifdef B4800 + return B4800; +#else + goto not_there; +#endif + if (strEQ(name, "B50")) +#ifdef B50 + return B50; +#else + goto not_there; +#endif + if (strEQ(name, "B600")) +#ifdef B600 + return B600; +#else + goto not_there; +#endif + if (strEQ(name, "B75")) +#ifdef B75 + return B75; +#else + goto not_there; +#endif + break; + case 'C': + if (strEQ(name, "CHAR_BIT")) +#ifdef CHAR_BIT + return CHAR_BIT; +#else + goto not_there; +#endif + if (strEQ(name, "CHAR_MAX")) +#ifdef CHAR_MAX + return CHAR_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "CHAR_MIN")) +#ifdef CHAR_MIN + return CHAR_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "CHILD_MAX")) +#ifdef CHILD_MAX + return CHILD_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "CLK_TCK")) +#ifdef CLK_TCK + return CLK_TCK; +#else + goto not_there; +#endif + if (strEQ(name, "CLOCAL")) +#ifdef CLOCAL + return CLOCAL; +#else + goto not_there; +#endif + if (strEQ(name, "CLOCKS_PER_SEC")) +#ifdef CLOCKS_PER_SEC + return CLOCKS_PER_SEC; +#else + goto not_there; +#endif + if (strEQ(name, "CREAD")) +#ifdef CREAD + return CREAD; +#else + goto not_there; +#endif + if (strEQ(name, "CS5")) +#ifdef CS5 + return CS5; +#else + goto not_there; +#endif + if (strEQ(name, "CS6")) +#ifdef CS6 + return CS6; +#else + goto not_there; +#endif + if (strEQ(name, "CS7")) +#ifdef CS7 + return CS7; +#else + goto not_there; +#endif + if (strEQ(name, "CS8")) +#ifdef CS8 + return CS8; +#else + goto not_there; +#endif + if (strEQ(name, "CSIZE")) +#ifdef CSIZE + return CSIZE; +#else + goto not_there; +#endif + if (strEQ(name, "CSTOPB")) +#ifdef CSTOPB + return CSTOPB; +#else + goto not_there; +#endif + break; + case 'D': + if (strEQ(name, "DBL_MAX")) +#ifdef DBL_MAX + return DBL_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MIN")) +#ifdef DBL_MIN + return DBL_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_DIG")) +#ifdef DBL_DIG + return DBL_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_EPSILON")) +#ifdef DBL_EPSILON + return DBL_EPSILON; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MANT_DIG")) +#ifdef DBL_MANT_DIG + return DBL_MANT_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MAX_10_EXP")) +#ifdef DBL_MAX_10_EXP + return DBL_MAX_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MAX_EXP")) +#ifdef DBL_MAX_EXP + return DBL_MAX_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MIN_10_EXP")) +#ifdef DBL_MIN_10_EXP + return DBL_MIN_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "DBL_MIN_EXP")) +#ifdef DBL_MIN_EXP + return DBL_MIN_EXP; +#else + goto not_there; +#endif + break; + case 'E': + switch (name[1]) { + case 'A': + if (strEQ(name, "EACCES")) +#ifdef EACCES + return EACCES; +#else + goto not_there; +#endif + if (strEQ(name, "EADDRINUSE")) +#ifdef EADDRINUSE + return EADDRINUSE; +#else + goto not_there; +#endif + if (strEQ(name, "EADDRNOTAVAIL")) +#ifdef EADDRNOTAVAIL + return EADDRNOTAVAIL; +#else + goto not_there; +#endif + if (strEQ(name, "EAFNOSUPPORT")) +#ifdef EAFNOSUPPORT + return EAFNOSUPPORT; +#else + goto not_there; +#endif + if (strEQ(name, "EAGAIN")) +#ifdef EAGAIN + return EAGAIN; +#else + goto not_there; +#endif + if (strEQ(name, "EALREADY")) +#ifdef EALREADY + return EALREADY; +#else + goto not_there; +#endif + break; + case 'B': + if (strEQ(name, "EBADF")) +#ifdef EBADF + return EBADF; +#else + goto not_there; +#endif + if (strEQ(name, "EBUSY")) +#ifdef EBUSY + return EBUSY; +#else + goto not_there; +#endif + break; + case 'C': + if (strEQ(name, "ECHILD")) +#ifdef ECHILD + return ECHILD; +#else + goto not_there; +#endif + if (strEQ(name, "ECHO")) +#ifdef ECHO + return ECHO; +#else + goto not_there; +#endif + if (strEQ(name, "ECHOE")) +#ifdef ECHOE + return ECHOE; +#else + goto not_there; +#endif + if (strEQ(name, "ECHOK")) +#ifdef ECHOK + return ECHOK; +#else + goto not_there; +#endif + if (strEQ(name, "ECHONL")) +#ifdef ECHONL + return ECHONL; +#else + goto not_there; +#endif + if (strEQ(name, "ECONNABORTED")) +#ifdef ECONNABORTED + return ECONNABORTED; +#else + goto not_there; +#endif + if (strEQ(name, "ECONNREFUSED")) +#ifdef ECONNREFUSED + return ECONNREFUSED; +#else + goto not_there; +#endif + if (strEQ(name, "ECONNRESET")) +#ifdef ECONNRESET + return ECONNRESET; +#else + goto not_there; +#endif + break; + case 'D': + if (strEQ(name, "EDEADLK")) +#ifdef EDEADLK + return EDEADLK; +#else + goto not_there; +#endif + if (strEQ(name, "EDESTADDRREQ")) +#ifdef EDESTADDRREQ + return EDESTADDRREQ; +#else + goto not_there; +#endif + if (strEQ(name, "EDOM")) +#ifdef EDOM + return EDOM; +#else + goto not_there; +#endif + if (strEQ(name, "EDQUOT")) +#ifdef EDQUOT + return EDQUOT; +#else + goto not_there; +#endif + break; + case 'E': + if (strEQ(name, "EEXIST")) +#ifdef EEXIST + return EEXIST; +#else + goto not_there; +#endif + break; + case 'F': + if (strEQ(name, "EFAULT")) +#ifdef EFAULT + return EFAULT; +#else + goto not_there; +#endif + if (strEQ(name, "EFBIG")) +#ifdef EFBIG + return EFBIG; +#else + goto not_there; +#endif + break; + case 'H': + if (strEQ(name, "EHOSTDOWN")) +#ifdef EHOSTDOWN + return EHOSTDOWN; +#else + goto not_there; +#endif + if (strEQ(name, "EHOSTUNREACH")) +#ifdef EHOSTUNREACH + return EHOSTUNREACH; +#else + goto not_there; +#endif + break; + case 'I': + if (strEQ(name, "EINPROGRESS")) +#ifdef EINPROGRESS + return EINPROGRESS; +#else + goto not_there; +#endif + if (strEQ(name, "EINTR")) +#ifdef EINTR + return EINTR; +#else + goto not_there; +#endif + if (strEQ(name, "EINVAL")) +#ifdef EINVAL + return EINVAL; +#else + goto not_there; +#endif + if (strEQ(name, "EIO")) +#ifdef EIO + return EIO; +#else + goto not_there; +#endif + if (strEQ(name, "EISCONN")) +#ifdef EISCONN + return EISCONN; +#else + goto not_there; +#endif + if (strEQ(name, "EISDIR")) +#ifdef EISDIR + return EISDIR; +#else + goto not_there; +#endif + break; + case 'L': + if (strEQ(name, "ELOOP")) +#ifdef ELOOP + return ELOOP; +#else + goto not_there; +#endif + break; + case 'M': + if (strEQ(name, "EMFILE")) +#ifdef EMFILE + return EMFILE; +#else + goto not_there; +#endif + if (strEQ(name, "EMLINK")) +#ifdef EMLINK + return EMLINK; +#else + goto not_there; +#endif + if (strEQ(name, "EMSGSIZE")) +#ifdef EMSGSIZE + return EMSGSIZE; +#else + goto not_there; +#endif + break; + case 'N': + if (strEQ(name, "ENETDOWN")) +#ifdef ENETDOWN + return ENETDOWN; +#else + goto not_there; +#endif + if (strEQ(name, "ENETRESET")) +#ifdef ENETRESET + return ENETRESET; +#else + goto not_there; +#endif + if (strEQ(name, "ENETUNREACH")) +#ifdef ENETUNREACH + return ENETUNREACH; +#else + goto not_there; +#endif + if (strEQ(name, "ENOBUFS")) +#ifdef ENOBUFS + return ENOBUFS; +#else + goto not_there; +#endif + if (strEQ(name, "ENOEXEC")) +#ifdef ENOEXEC + return ENOEXEC; +#else + goto not_there; +#endif + if (strEQ(name, "ENOMEM")) +#ifdef ENOMEM + return ENOMEM; +#else + goto not_there; +#endif + if (strEQ(name, "ENOPROTOOPT")) +#ifdef ENOPROTOOPT + return ENOPROTOOPT; +#else + goto not_there; +#endif + if (strEQ(name, "ENOSPC")) +#ifdef ENOSPC + return ENOSPC; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTBLK")) +#ifdef ENOTBLK + return ENOTBLK; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTCONN")) +#ifdef ENOTCONN + return ENOTCONN; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTDIR")) +#ifdef ENOTDIR + return ENOTDIR; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTEMPTY")) +#ifdef ENOTEMPTY + return ENOTEMPTY; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTSOCK")) +#ifdef ENOTSOCK + return ENOTSOCK; +#else + goto not_there; +#endif + if (strEQ(name, "ENOTTY")) +#ifdef ENOTTY + return ENOTTY; +#else + goto not_there; +#endif + if (strEQ(name, "ENFILE")) +#ifdef ENFILE + return ENFILE; +#else + goto not_there; +#endif + if (strEQ(name, "ENODEV")) +#ifdef ENODEV + return ENODEV; +#else + goto not_there; +#endif + if (strEQ(name, "ENOENT")) +#ifdef ENOENT + return ENOENT; +#else + goto not_there; +#endif + if (strEQ(name, "ENOLCK")) +#ifdef ENOLCK + return ENOLCK; +#else + goto not_there; +#endif + if (strEQ(name, "ENOSYS")) +#ifdef ENOSYS + return ENOSYS; +#else + goto not_there; +#endif + if (strEQ(name, "ENXIO")) +#ifdef ENXIO + return ENXIO; +#else + goto not_there; +#endif + if (strEQ(name, "ENAMETOOLONG")) +#ifdef ENAMETOOLONG + return ENAMETOOLONG; +#else + goto not_there; +#endif + break; + case 'O': + if (strEQ(name, "EOF")) +#ifdef EOF + return EOF; +#else + goto not_there; +#endif + if (strEQ(name, "EOPNOTSUPP")) +#ifdef EOPNOTSUPP + return EOPNOTSUPP; +#else + goto not_there; +#endif + break; + case 'P': + if (strEQ(name, "EPERM")) +#ifdef EPERM + return EPERM; +#else + goto not_there; +#endif + if (strEQ(name, "EPFNOSUPPORT")) +#ifdef EPFNOSUPPORT + return EPFNOSUPPORT; +#else + goto not_there; +#endif + if (strEQ(name, "EPIPE")) +#ifdef EPIPE + return EPIPE; +#else + goto not_there; +#endif + if (strEQ(name, "EPROCLIM")) +#ifdef EPROCLIM + return EPROCLIM; +#else + goto not_there; +#endif + if (strEQ(name, "EPROTONOSUPPORT")) +#ifdef EPROTONOSUPPORT + return EPROTONOSUPPORT; +#else + goto not_there; +#endif + if (strEQ(name, "EPROTOTYPE")) +#ifdef EPROTOTYPE + return EPROTOTYPE; +#else + goto not_there; +#endif + break; + case 'R': + if (strEQ(name, "ERANGE")) +#ifdef ERANGE + return ERANGE; +#else + goto not_there; +#endif + if (strEQ(name, "EREMOTE")) +#ifdef EREMOTE + return EREMOTE; +#else + goto not_there; +#endif + if (strEQ(name, "ERESTART")) +#ifdef ERESTART + return ERESTART; +#else + goto not_there; +#endif + if (strEQ(name, "EROFS")) +#ifdef EROFS + return EROFS; +#else + goto not_there; +#endif + break; + case 'S': + if (strEQ(name, "ESHUTDOWN")) +#ifdef ESHUTDOWN + return ESHUTDOWN; +#else + goto not_there; +#endif + if (strEQ(name, "ESOCKTNOSUPPORT")) +#ifdef ESOCKTNOSUPPORT + return ESOCKTNOSUPPORT; +#else + goto not_there; +#endif + if (strEQ(name, "ESPIPE")) +#ifdef ESPIPE + return ESPIPE; +#else + goto not_there; +#endif + if (strEQ(name, "ESRCH")) +#ifdef ESRCH + return ESRCH; +#else + goto not_there; +#endif + if (strEQ(name, "ESTALE")) +#ifdef ESTALE + return ESTALE; +#else + goto not_there; +#endif + break; + case 'T': + if (strEQ(name, "ETIMEDOUT")) +#ifdef ETIMEDOUT + return ETIMEDOUT; +#else + goto not_there; +#endif + if (strEQ(name, "ETOOMANYREFS")) +#ifdef ETOOMANYREFS + return ETOOMANYREFS; +#else + goto not_there; +#endif + if (strEQ(name, "ETXTBSY")) +#ifdef ETXTBSY + return ETXTBSY; +#else + goto not_there; +#endif + break; + case 'U': + if (strEQ(name, "EUSERS")) +#ifdef EUSERS + return EUSERS; +#else + goto not_there; +#endif + break; + case 'W': + if (strEQ(name, "EWOULDBLOCK")) +#ifdef EWOULDBLOCK + return EWOULDBLOCK; +#else + goto not_there; +#endif + break; + case 'X': + if (strEQ(name, "EXIT_FAILURE")) +#ifdef EXIT_FAILURE + return EXIT_FAILURE; +#else + return 1; +#endif + if (strEQ(name, "EXIT_SUCCESS")) +#ifdef EXIT_SUCCESS + return EXIT_SUCCESS; +#else + return 0; +#endif + if (strEQ(name, "EXDEV")) +#ifdef EXDEV + return EXDEV; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "E2BIG")) +#ifdef E2BIG + return E2BIG; +#else + goto not_there; +#endif + break; + case 'F': + if (strnEQ(name, "FLT_", 4)) { + if (strEQ(name, "FLT_MAX")) +#ifdef FLT_MAX + return FLT_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MIN")) +#ifdef FLT_MIN + return FLT_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_ROUNDS")) +#ifdef FLT_ROUNDS + return FLT_ROUNDS; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_DIG")) +#ifdef FLT_DIG + return FLT_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_EPSILON")) +#ifdef FLT_EPSILON + return FLT_EPSILON; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MANT_DIG")) +#ifdef FLT_MANT_DIG + return FLT_MANT_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MAX_10_EXP")) +#ifdef FLT_MAX_10_EXP + return FLT_MAX_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MAX_EXP")) +#ifdef FLT_MAX_EXP + return FLT_MAX_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MIN_10_EXP")) +#ifdef FLT_MIN_10_EXP + return FLT_MIN_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_MIN_EXP")) +#ifdef FLT_MIN_EXP + return FLT_MIN_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "FLT_RADIX")) +#ifdef FLT_RADIX + return FLT_RADIX; +#else + goto not_there; +#endif + break; + } + if (strnEQ(name, "F_", 2)) { + if (strEQ(name, "F_DUPFD")) +#ifdef F_DUPFD + return F_DUPFD; +#else + goto not_there; +#endif + if (strEQ(name, "F_GETFD")) +#ifdef F_GETFD + return F_GETFD; +#else + goto not_there; +#endif + if (strEQ(name, "F_GETFL")) +#ifdef F_GETFL + return F_GETFL; +#else + goto not_there; +#endif + if (strEQ(name, "F_GETLK")) +#ifdef F_GETLK + return F_GETLK; +#else + goto not_there; +#endif + if (strEQ(name, "F_OK")) +#ifdef F_OK + return F_OK; +#else + goto not_there; +#endif + if (strEQ(name, "F_RDLCK")) +#ifdef F_RDLCK + return F_RDLCK; +#else + goto not_there; +#endif + if (strEQ(name, "F_SETFD")) +#ifdef F_SETFD + return F_SETFD; +#else + goto not_there; +#endif + if (strEQ(name, "F_SETFL")) +#ifdef F_SETFL + return F_SETFL; +#else + goto not_there; +#endif + if (strEQ(name, "F_SETLK")) +#ifdef F_SETLK + return F_SETLK; +#else + goto not_there; +#endif + if (strEQ(name, "F_SETLKW")) +#ifdef F_SETLKW + return F_SETLKW; +#else + goto not_there; +#endif + if (strEQ(name, "F_UNLCK")) +#ifdef F_UNLCK + return F_UNLCK; +#else + goto not_there; +#endif + if (strEQ(name, "F_WRLCK")) +#ifdef F_WRLCK + return F_WRLCK; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "FD_CLOEXEC")) +#ifdef FD_CLOEXEC + return FD_CLOEXEC; +#else + goto not_there; +#endif + if (strEQ(name, "FILENAME_MAX")) +#ifdef FILENAME_MAX + return FILENAME_MAX; +#else + goto not_there; +#endif + break; + case 'H': + if (strEQ(name, "HUGE_VAL")) +#ifdef HUGE_VAL + return HUGE_VAL; +#else + goto not_there; +#endif + if (strEQ(name, "HUPCL")) +#ifdef HUPCL + return HUPCL; +#else + goto not_there; +#endif + break; + case 'I': + if (strEQ(name, "INT_MAX")) +#ifdef INT_MAX + return INT_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "INT_MIN")) +#ifdef INT_MIN + return INT_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "ICANON")) +#ifdef ICANON + return ICANON; +#else + goto not_there; +#endif + if (strEQ(name, "ICRNL")) +#ifdef ICRNL + return ICRNL; +#else + goto not_there; +#endif + if (strEQ(name, "IEXTEN")) +#ifdef IEXTEN + return IEXTEN; +#else + goto not_there; +#endif + if (strEQ(name, "IGNBRK")) +#ifdef IGNBRK + return IGNBRK; +#else + goto not_there; +#endif + if (strEQ(name, "IGNCR")) +#ifdef IGNCR + return IGNCR; +#else + goto not_there; +#endif + if (strEQ(name, "IGNPAR")) +#ifdef IGNPAR + return IGNPAR; +#else + goto not_there; +#endif + if (strEQ(name, "INLCR")) +#ifdef INLCR + return INLCR; +#else + goto not_there; +#endif + if (strEQ(name, "INPCK")) +#ifdef INPCK + return INPCK; +#else + goto not_there; +#endif + if (strEQ(name, "ISIG")) +#ifdef ISIG + return ISIG; +#else + goto not_there; +#endif + if (strEQ(name, "ISTRIP")) +#ifdef ISTRIP + return ISTRIP; +#else + goto not_there; +#endif + if (strEQ(name, "IXOFF")) +#ifdef IXOFF + return IXOFF; +#else + goto not_there; +#endif + if (strEQ(name, "IXON")) +#ifdef IXON + return IXON; +#else + goto not_there; +#endif + break; + case 'L': + if (strnEQ(name, "LC_", 3)) { + if (strEQ(name, "LC_ALL")) +#ifdef LC_ALL + return LC_ALL; +#else + goto not_there; +#endif + if (strEQ(name, "LC_COLLATE")) +#ifdef LC_COLLATE + return LC_COLLATE; +#else + goto not_there; +#endif + if (strEQ(name, "LC_CTYPE")) +#ifdef LC_CTYPE + return LC_CTYPE; +#else + goto not_there; +#endif + if (strEQ(name, "LC_MONETARY")) +#ifdef LC_MONETARY + return LC_MONETARY; +#else + goto not_there; +#endif + if (strEQ(name, "LC_NUMERIC")) +#ifdef LC_NUMERIC + return LC_NUMERIC; +#else + goto not_there; +#endif + if (strEQ(name, "LC_TIME")) +#ifdef LC_TIME + return LC_TIME; +#else + goto not_there; +#endif + break; + } + if (strnEQ(name, "LDBL_", 5)) { + if (strEQ(name, "LDBL_MAX")) +#ifdef LDBL_MAX + return LDBL_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MIN")) +#ifdef LDBL_MIN + return LDBL_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_DIG")) +#ifdef LDBL_DIG + return LDBL_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_EPSILON")) +#ifdef LDBL_EPSILON + return LDBL_EPSILON; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MANT_DIG")) +#ifdef LDBL_MANT_DIG + return LDBL_MANT_DIG; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MAX_10_EXP")) +#ifdef LDBL_MAX_10_EXP + return LDBL_MAX_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MAX_EXP")) +#ifdef LDBL_MAX_EXP + return LDBL_MAX_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MIN_10_EXP")) +#ifdef LDBL_MIN_10_EXP + return LDBL_MIN_10_EXP; +#else + goto not_there; +#endif + if (strEQ(name, "LDBL_MIN_EXP")) +#ifdef LDBL_MIN_EXP + return LDBL_MIN_EXP; +#else + goto not_there; +#endif + break; + } + if (strnEQ(name, "L_", 2)) { + if (strEQ(name, "L_ctermid")) +#ifdef L_ctermid + return L_ctermid; +#else + goto not_there; +#endif + if (strEQ(name, "L_cuserid")) +#ifdef L_cuserid + return L_cuserid; +#else + goto not_there; +#endif + if (strEQ(name, "L_tmpname")) +#ifdef L_tmpname + return L_tmpname; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "LONG_MAX")) +#ifdef LONG_MAX + return LONG_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "LONG_MIN")) +#ifdef LONG_MIN + return LONG_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "LINK_MAX")) +#ifdef LINK_MAX + return LINK_MAX; +#else + goto not_there; +#endif + break; + case 'M': + if (strEQ(name, "MAX_CANON")) +#ifdef MAX_CANON + return MAX_CANON; +#else + goto not_there; +#endif + if (strEQ(name, "MAX_INPUT")) +#ifdef MAX_INPUT + return MAX_INPUT; +#else + goto not_there; +#endif + if (strEQ(name, "MB_CUR_MAX")) +#ifdef MB_CUR_MAX + return MB_CUR_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "MB_LEN_MAX")) +#ifdef MB_LEN_MAX + return MB_LEN_MAX; +#else + goto not_there; +#endif + break; + case 'N': + if (strEQ(name, "NULL")) return 0; + if (strEQ(name, "NAME_MAX")) +#ifdef NAME_MAX + return NAME_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "NCCS")) +#ifdef NCCS + return NCCS; +#else + goto not_there; +#endif + if (strEQ(name, "NGROUPS_MAX")) +#ifdef NGROUPS_MAX + return NGROUPS_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "NOFLSH")) +#ifdef NOFLSH + return NOFLSH; +#else + goto not_there; +#endif + break; + case 'O': + if (strnEQ(name, "O_", 2)) { + if (strEQ(name, "O_APPEND")) +#ifdef O_APPEND + return O_APPEND; +#else + goto not_there; +#endif + if (strEQ(name, "O_CREAT")) +#ifdef O_CREAT + return O_CREAT; +#else + goto not_there; +#endif + if (strEQ(name, "O_TRUNC")) +#ifdef O_TRUNC + return O_TRUNC; +#else + goto not_there; +#endif + if (strEQ(name, "O_RDONLY")) +#ifdef O_RDONLY + return O_RDONLY; +#else + goto not_there; +#endif + if (strEQ(name, "O_RDWR")) +#ifdef O_RDWR + return O_RDWR; +#else + goto not_there; +#endif + if (strEQ(name, "O_WRONLY")) +#ifdef O_WRONLY + return O_WRONLY; +#else + goto not_there; +#endif + if (strEQ(name, "O_EXCL")) +#ifdef O_EXCL + return O_EXCL; +#else + goto not_there; +#endif + if (strEQ(name, "O_NOCTTY")) +#ifdef O_NOCTTY + return O_NOCTTY; +#else + goto not_there; +#endif + if (strEQ(name, "O_NONBLOCK")) +#ifdef O_NONBLOCK + return O_NONBLOCK; +#else + goto not_there; +#endif + if (strEQ(name, "O_ACCMODE")) +#ifdef O_ACCMODE + return O_ACCMODE; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "OPEN_MAX")) +#ifdef OPEN_MAX + return OPEN_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "OPOST")) +#ifdef OPOST + return OPOST; +#else + goto not_there; +#endif + break; + case 'P': + if (strEQ(name, "PATH_MAX")) +#ifdef PATH_MAX + return PATH_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "PARENB")) +#ifdef PARENB + return PARENB; +#else + goto not_there; +#endif + if (strEQ(name, "PARMRK")) +#ifdef PARMRK + return PARMRK; +#else + goto not_there; +#endif + if (strEQ(name, "PARODD")) +#ifdef PARODD + return PARODD; +#else + goto not_there; +#endif + if (strEQ(name, "PIPE_BUF")) +#ifdef PIPE_BUF + return PIPE_BUF; +#else + goto not_there; +#endif + break; + case 'R': + if (strEQ(name, "RAND_MAX")) +#ifdef RAND_MAX + return RAND_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "R_OK")) +#ifdef R_OK + return R_OK; +#else + goto not_there; +#endif + break; + case 'S': + if (strnEQ(name, "SIG", 3)) { + if (name[3] == '_') { + if (strEQ(name, "SIG_BLOCK")) +#ifdef SIG_BLOCK + return SIG_BLOCK; +#else + goto not_there; +#endif +#ifdef SIG_DFL + if (strEQ(name, "SIG_DFL")) return (IV)SIG_DFL; +#endif +#ifdef SIG_ERR + if (strEQ(name, "SIG_ERR")) return (IV)SIG_ERR; +#endif +#ifdef SIG_IGN + if (strEQ(name, "SIG_IGN")) return (IV)SIG_IGN; +#endif + if (strEQ(name, "SIG_SETMASK")) +#ifdef SIG_SETMASK + return SIG_SETMASK; +#else + goto not_there; +#endif + if (strEQ(name, "SIG_UNBLOCK")) +#ifdef SIG_UNBLOCK + return SIG_UNBLOCK; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "SIGABRT")) +#ifdef SIGABRT + return SIGABRT; +#else + goto not_there; +#endif + if (strEQ(name, "SIGALRM")) +#ifdef SIGALRM + return SIGALRM; +#else + goto not_there; +#endif + if (strEQ(name, "SIGCHLD")) +#ifdef SIGCHLD + return SIGCHLD; +#else + goto not_there; +#endif + if (strEQ(name, "SIGCONT")) +#ifdef SIGCONT + return SIGCONT; +#else + goto not_there; +#endif + if (strEQ(name, "SIGFPE")) +#ifdef SIGFPE + return SIGFPE; +#else + goto not_there; +#endif + if (strEQ(name, "SIGHUP")) +#ifdef SIGHUP + return SIGHUP; +#else + goto not_there; +#endif + if (strEQ(name, "SIGILL")) +#ifdef SIGILL + return SIGILL; +#else + goto not_there; +#endif + if (strEQ(name, "SIGINT")) +#ifdef SIGINT + return SIGINT; +#else + goto not_there; +#endif + if (strEQ(name, "SIGKILL")) +#ifdef SIGKILL + return SIGKILL; +#else + goto not_there; +#endif + if (strEQ(name, "SIGPIPE")) +#ifdef SIGPIPE + return SIGPIPE; +#else + goto not_there; +#endif + if (strEQ(name, "SIGQUIT")) +#ifdef SIGQUIT + return SIGQUIT; +#else + goto not_there; +#endif + if (strEQ(name, "SIGSEGV")) +#ifdef SIGSEGV + return SIGSEGV; +#else + goto not_there; +#endif + if (strEQ(name, "SIGSTOP")) +#ifdef SIGSTOP + return SIGSTOP; +#else + goto not_there; +#endif + if (strEQ(name, "SIGTERM")) +#ifdef SIGTERM + return SIGTERM; +#else + goto not_there; +#endif + if (strEQ(name, "SIGTSTP")) +#ifdef SIGTSTP + return SIGTSTP; +#else + goto not_there; +#endif + if (strEQ(name, "SIGTTIN")) +#ifdef SIGTTIN + return SIGTTIN; +#else + goto not_there; +#endif + if (strEQ(name, "SIGTTOU")) +#ifdef SIGTTOU + return SIGTTOU; +#else + goto not_there; +#endif + if (strEQ(name, "SIGUSR1")) +#ifdef SIGUSR1 + return SIGUSR1; +#else + goto not_there; +#endif + if (strEQ(name, "SIGUSR2")) +#ifdef SIGUSR2 + return SIGUSR2; +#else + goto not_there; +#endif + break; + } + if (name[1] == '_') { + if (strEQ(name, "S_ISGID")) +#ifdef S_ISGID + return S_ISGID; +#else + goto not_there; +#endif + if (strEQ(name, "S_ISUID")) +#ifdef S_ISUID + return S_ISUID; +#else + goto not_there; +#endif + if (strEQ(name, "S_IRGRP")) +#ifdef S_IRGRP + return S_IRGRP; +#else + goto not_there; +#endif + if (strEQ(name, "S_IROTH")) +#ifdef S_IROTH + return S_IROTH; +#else + goto not_there; +#endif + if (strEQ(name, "S_IRUSR")) +#ifdef S_IRUSR + return S_IRUSR; +#else + goto not_there; +#endif + if (strEQ(name, "S_IRWXG")) +#ifdef S_IRWXG + return S_IRWXG; +#else + goto not_there; +#endif + if (strEQ(name, "S_IRWXO")) +#ifdef S_IRWXO + return S_IRWXO; +#else + goto not_there; +#endif + if (strEQ(name, "S_IRWXU")) +#ifdef S_IRWXU + return S_IRWXU; +#else + goto not_there; +#endif + if (strEQ(name, "S_IWGRP")) +#ifdef S_IWGRP + return S_IWGRP; +#else + goto not_there; +#endif + if (strEQ(name, "S_IWOTH")) +#ifdef S_IWOTH + return S_IWOTH; +#else + goto not_there; +#endif + if (strEQ(name, "S_IWUSR")) +#ifdef S_IWUSR + return S_IWUSR; +#else + goto not_there; +#endif + if (strEQ(name, "S_IXGRP")) +#ifdef S_IXGRP + return S_IXGRP; +#else + goto not_there; +#endif + if (strEQ(name, "S_IXOTH")) +#ifdef S_IXOTH + return S_IXOTH; +#else + goto not_there; +#endif + if (strEQ(name, "S_IXUSR")) +#ifdef S_IXUSR + return S_IXUSR; +#else + goto not_there; +#endif + errno = EAGAIN; /* the following aren't constants */ +#ifdef S_ISBLK + if (strEQ(name, "S_ISBLK")) return S_ISBLK(arg); +#endif +#ifdef S_ISCHR + if (strEQ(name, "S_ISCHR")) return S_ISCHR(arg); +#endif +#ifdef S_ISDIR + if (strEQ(name, "S_ISDIR")) return S_ISDIR(arg); +#endif +#ifdef S_ISFIFO + if (strEQ(name, "S_ISFIFO")) return S_ISFIFO(arg); +#endif +#ifdef S_ISREG + if (strEQ(name, "S_ISREG")) return S_ISREG(arg); +#endif + break; + } + if (strEQ(name, "SEEK_CUR")) +#ifdef SEEK_CUR + return SEEK_CUR; +#else + goto not_there; +#endif + if (strEQ(name, "SEEK_END")) +#ifdef SEEK_END + return SEEK_END; +#else + goto not_there; +#endif + if (strEQ(name, "SEEK_SET")) +#ifdef SEEK_SET + return SEEK_SET; +#else + goto not_there; +#endif + if (strEQ(name, "STREAM_MAX")) +#ifdef STREAM_MAX + return STREAM_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "SHRT_MAX")) +#ifdef SHRT_MAX + return SHRT_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "SHRT_MIN")) +#ifdef SHRT_MIN + return SHRT_MIN; +#else + goto not_there; +#endif + if (strnEQ(name, "SA_", 3)) { + if (strEQ(name, "SA_NOCLDSTOP")) +#ifdef SA_NOCLDSTOP + return SA_NOCLDSTOP; +#else + goto not_there; +#endif + if (strEQ(name, "SA_NOCLDWAIT")) +#ifdef SA_NOCLDWAIT + return SA_NOCLDWAIT; +#else + goto not_there; +#endif + if (strEQ(name, "SA_NODEFER")) +#ifdef SA_NODEFER + return SA_NODEFER; +#else + goto not_there; +#endif + if (strEQ(name, "SA_ONSTACK")) +#ifdef SA_ONSTACK + return SA_ONSTACK; +#else + goto not_there; +#endif + if (strEQ(name, "SA_RESETHAND")) +#ifdef SA_RESETHAND + return SA_RESETHAND; +#else + goto not_there; +#endif + if (strEQ(name, "SA_RESTART")) +#ifdef SA_RESTART + return SA_RESTART; +#else + goto not_there; +#endif + if (strEQ(name, "SA_SIGINFO")) +#ifdef SA_SIGINFO + return SA_SIGINFO; +#else + goto not_there; +#endif + break; + } + if (strEQ(name, "SCHAR_MAX")) +#ifdef SCHAR_MAX + return SCHAR_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "SCHAR_MIN")) +#ifdef SCHAR_MIN + return SCHAR_MIN; +#else + goto not_there; +#endif + if (strEQ(name, "SSIZE_MAX")) +#ifdef SSIZE_MAX + return SSIZE_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "STDIN_FILENO")) +#ifdef STDIN_FILENO + return STDIN_FILENO; +#else + goto not_there; +#endif + if (strEQ(name, "STDOUT_FILENO")) +#ifdef STDOUT_FILENO + return STDOUT_FILENO; +#else + goto not_there; +#endif + if (strEQ(name, "STRERR_FILENO")) +#ifdef STRERR_FILENO + return STRERR_FILENO; +#else + goto not_there; +#endif + break; + case 'T': + if (strEQ(name, "TCIFLUSH")) +#ifdef TCIFLUSH + return TCIFLUSH; +#else + goto not_there; +#endif + if (strEQ(name, "TCIOFF")) +#ifdef TCIOFF + return TCIOFF; +#else + goto not_there; +#endif + if (strEQ(name, "TCIOFLUSH")) +#ifdef TCIOFLUSH + return TCIOFLUSH; +#else + goto not_there; +#endif + if (strEQ(name, "TCION")) +#ifdef TCION + return TCION; +#else + goto not_there; +#endif + if (strEQ(name, "TCOFLUSH")) +#ifdef TCOFLUSH + return TCOFLUSH; +#else + goto not_there; +#endif + if (strEQ(name, "TCOOFF")) +#ifdef TCOOFF + return TCOOFF; +#else + goto not_there; +#endif + if (strEQ(name, "TCOON")) +#ifdef TCOON + return TCOON; +#else + goto not_there; +#endif + if (strEQ(name, "TCSADRAIN")) +#ifdef TCSADRAIN + return TCSADRAIN; +#else + goto not_there; +#endif + if (strEQ(name, "TCSAFLUSH")) +#ifdef TCSAFLUSH + return TCSAFLUSH; +#else + goto not_there; +#endif + if (strEQ(name, "TCSANOW")) +#ifdef TCSANOW + return TCSANOW; +#else + goto not_there; +#endif + if (strEQ(name, "TMP_MAX")) +#ifdef TMP_MAX + return TMP_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "TOSTOP")) +#ifdef TOSTOP + return TOSTOP; +#else + goto not_there; +#endif + if (strEQ(name, "TZNAME_MAX")) +#ifdef TZNAME_MAX + return TZNAME_MAX; +#else + goto not_there; +#endif + break; + case 'U': + if (strEQ(name, "UCHAR_MAX")) +#ifdef UCHAR_MAX + return UCHAR_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "UINT_MAX")) +#ifdef UINT_MAX + return UINT_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "ULONG_MAX")) +#ifdef ULONG_MAX + return ULONG_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "USHRT_MAX")) +#ifdef USHRT_MAX + return USHRT_MAX; +#else + goto not_there; +#endif + break; + case 'V': + if (strEQ(name, "VEOF")) +#ifdef VEOF + return VEOF; +#else + goto not_there; +#endif + if (strEQ(name, "VEOL")) +#ifdef VEOL + return VEOL; +#else + goto not_there; +#endif + if (strEQ(name, "VERASE")) +#ifdef VERASE + return VERASE; +#else + goto not_there; +#endif + if (strEQ(name, "VINTR")) +#ifdef VINTR + return VINTR; +#else + goto not_there; +#endif + if (strEQ(name, "VKILL")) +#ifdef VKILL + return VKILL; +#else + goto not_there; +#endif + if (strEQ(name, "VMIN")) +#ifdef VMIN + return VMIN; +#else + goto not_there; +#endif + if (strEQ(name, "VQUIT")) +#ifdef VQUIT + return VQUIT; +#else + goto not_there; +#endif + if (strEQ(name, "VSTART")) +#ifdef VSTART + return VSTART; +#else + goto not_there; +#endif + if (strEQ(name, "VSTOP")) +#ifdef VSTOP + return VSTOP; +#else + goto not_there; +#endif + if (strEQ(name, "VSUSP")) +#ifdef VSUSP + return VSUSP; +#else + goto not_there; +#endif + if (strEQ(name, "VTIME")) +#ifdef VTIME + return VTIME; +#else + goto not_there; +#endif + break; + case 'W': + if (strEQ(name, "W_OK")) +#ifdef W_OK + return W_OK; +#else + goto not_there; +#endif + if (strEQ(name, "WNOHANG")) +#ifdef WNOHANG + return WNOHANG; +#else + goto not_there; +#endif + if (strEQ(name, "WUNTRACED")) +#ifdef WUNTRACED + return WUNTRACED; +#else + goto not_there; +#endif + errno = EAGAIN; /* the following aren't constants */ +#ifdef WEXITSTATUS + if (strEQ(name, "WEXITSTATUS")) return WEXITSTATUS(arg); +#endif +#ifdef WIFEXITED + if (strEQ(name, "WIFEXITED")) return WIFEXITED(arg); +#endif +#ifdef WIFSIGNALED + if (strEQ(name, "WIFSIGNALED")) return WIFSIGNALED(arg); +#endif +#ifdef WIFSTOPPED + if (strEQ(name, "WIFSTOPPED")) return WIFSTOPPED(arg); +#endif +#ifdef WSTOPSIG + if (strEQ(name, "WSTOPSIG")) return WSTOPSIG(arg); +#endif +#ifdef WTERMSIG + if (strEQ(name, "WTERMSIG")) return WTERMSIG(arg); +#endif + break; + case 'X': + if (strEQ(name, "X_OK")) +#ifdef X_OK + return X_OK; +#else + goto not_there; +#endif + break; + case '_': + if (strnEQ(name, "_PC_", 4)) { + if (strEQ(name, "_PC_CHOWN_RESTRICTED")) +#if defined(_PC_CHOWN_RESTRICTED) || HINT_SC_EXIST + return _PC_CHOWN_RESTRICTED; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_LINK_MAX")) +#if defined(_PC_LINK_MAX) || HINT_SC_EXIST + return _PC_LINK_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_MAX_CANON")) +#if defined(_PC_MAX_CANON) || HINT_SC_EXIST + return _PC_MAX_CANON; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_MAX_INPUT")) +#if defined(_PC_MAX_INPUT) || HINT_SC_EXIST + return _PC_MAX_INPUT; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_NAME_MAX")) +#if defined(_PC_NAME_MAX) || HINT_SC_EXIST + return _PC_NAME_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_NO_TRUNC")) +#if defined(_PC_NO_TRUNC) || HINT_SC_EXIST + return _PC_NO_TRUNC; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_PATH_MAX")) +#if defined(_PC_PATH_MAX) || HINT_SC_EXIST + return _PC_PATH_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_PIPE_BUF")) +#if defined(_PC_PIPE_BUF) || HINT_SC_EXIST + return _PC_PIPE_BUF; +#else + goto not_there; +#endif + if (strEQ(name, "_PC_VDISABLE")) +#if defined(_PC_VDISABLE) || HINT_SC_EXIST + return _PC_VDISABLE; +#else + goto not_there; +#endif + break; + } + if (strnEQ(name, "_POSIX_", 7)) { + if (strEQ(name, "_POSIX_ARG_MAX")) +#ifdef _POSIX_ARG_MAX + return _POSIX_ARG_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_CHILD_MAX")) +#ifdef _POSIX_CHILD_MAX + return _POSIX_CHILD_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_CHOWN_RESTRICTED")) +#ifdef _POSIX_CHOWN_RESTRICTED + return _POSIX_CHOWN_RESTRICTED; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_JOB_CONTROL")) +#ifdef _POSIX_JOB_CONTROL + return _POSIX_JOB_CONTROL; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_LINK_MAX")) +#ifdef _POSIX_LINK_MAX + return _POSIX_LINK_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_MAX_CANON")) +#ifdef _POSIX_MAX_CANON + return _POSIX_MAX_CANON; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_MAX_INPUT")) +#ifdef _POSIX_MAX_INPUT + return _POSIX_MAX_INPUT; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_NAME_MAX")) +#ifdef _POSIX_NAME_MAX + return _POSIX_NAME_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_NGROUPS_MAX")) +#ifdef _POSIX_NGROUPS_MAX + return _POSIX_NGROUPS_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_NO_TRUNC")) +#ifdef _POSIX_NO_TRUNC + return _POSIX_NO_TRUNC; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_OPEN_MAX")) +#ifdef _POSIX_OPEN_MAX + return _POSIX_OPEN_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_PATH_MAX")) +#ifdef _POSIX_PATH_MAX + return _POSIX_PATH_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_PIPE_BUF")) +#ifdef _POSIX_PIPE_BUF + return _POSIX_PIPE_BUF; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_SAVED_IDS")) +#ifdef _POSIX_SAVED_IDS + return _POSIX_SAVED_IDS; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_SSIZE_MAX")) +#ifdef _POSIX_SSIZE_MAX + return _POSIX_SSIZE_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_STREAM_MAX")) +#ifdef _POSIX_STREAM_MAX + return _POSIX_STREAM_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_TZNAME_MAX")) +#ifdef _POSIX_TZNAME_MAX + return _POSIX_TZNAME_MAX; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_VDISABLE")) +#ifdef _POSIX_VDISABLE + return _POSIX_VDISABLE; +#else + return 0; +#endif + if (strEQ(name, "_POSIX_VERSION")) +#ifdef _POSIX_VERSION + return _POSIX_VERSION; +#else + return 0; +#endif + break; + } + if (strnEQ(name, "_SC_", 4)) { + if (strEQ(name, "_SC_ARG_MAX")) +#if defined(_SC_ARG_MAX) || HINT_SC_EXIST + return _SC_ARG_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_CHILD_MAX")) +#if defined(_SC_CHILD_MAX) || HINT_SC_EXIST + return _SC_CHILD_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_CLK_TCK")) +#if defined(_SC_CLK_TCK) || HINT_SC_EXIST + return _SC_CLK_TCK; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_JOB_CONTROL")) +#if defined(_SC_JOB_CONTROL) || HINT_SC_EXIST + return _SC_JOB_CONTROL; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_NGROUPS_MAX")) +#if defined(_SC_NGROUPS_MAX) || HINT_SC_EXIST + return _SC_NGROUPS_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_OPEN_MAX")) +#if defined(_SC_OPEN_MAX) || HINT_SC_EXIST + return _SC_OPEN_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_SAVED_IDS")) +#if defined(_SC_SAVED_IDS) || HINT_SC_EXIST + return _SC_SAVED_IDS; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_STREAM_MAX")) +#if defined(_SC_STREAM_MAX) || HINT_SC_EXIST + return _SC_STREAM_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_TZNAME_MAX")) +#if defined(_SC_TZNAME_MAX) || HINT_SC_EXIST + return _SC_TZNAME_MAX; +#else + goto not_there; +#endif + if (strEQ(name, "_SC_VERSION")) +#if defined(_SC_VERSION) || HINT_SC_EXIST + return _SC_VERSION; +#else + goto not_there; +#endif + break; + } + } + errno = EINVAL; + return 0; + +not_there: + errno = ENOENT; + return 0; +} + +MODULE = SigSet PACKAGE = POSIX::SigSet PREFIX = sig + +POSIX::SigSet +new(packname = "POSIX::SigSet", ...) + char * packname + CODE: + { + int i; + RETVAL = (sigset_t*)safemalloc(sizeof(sigset_t)); + sigemptyset(RETVAL); + for (i = 1; i < items; i++) + sigaddset(RETVAL, SvIV(ST(i))); + } + OUTPUT: + RETVAL + +void +DESTROY(sigset) + POSIX::SigSet sigset + CODE: + safefree((char *)sigset); + +SysRet +sigaddset(sigset, sig) + POSIX::SigSet sigset + int sig + +SysRet +sigdelset(sigset, sig) + POSIX::SigSet sigset + int sig + +SysRet +sigemptyset(sigset) + POSIX::SigSet sigset + +SysRet +sigfillset(sigset) + POSIX::SigSet sigset + +int +sigismember(sigset, sig) + POSIX::SigSet sigset + int sig + + +MODULE = Termios PACKAGE = POSIX::Termios PREFIX = cf + +POSIX::Termios +new(packname = "POSIX::Termios", ...) + char * packname + CODE: + { +#ifdef I_TERMIOS + RETVAL = (struct termios*)safemalloc(sizeof(struct termios)); +#else + not_here("termios"); + RETVAL = 0; +#endif + } + OUTPUT: + RETVAL + +void +DESTROY(termios_ref) + POSIX::Termios termios_ref + CODE: +#ifdef I_TERMIOS + safefree((char *)termios_ref); +#else + not_here("termios"); +#endif + +SysRet +getattr(termios_ref, fd = 0) + POSIX::Termios termios_ref + int fd + CODE: + RETVAL = tcgetattr(fd, termios_ref); + OUTPUT: + RETVAL + +SysRet +setattr(termios_ref, fd = 0, optional_actions = 0) + POSIX::Termios termios_ref + int fd + int optional_actions + CODE: + RETVAL = tcsetattr(fd, optional_actions, termios_ref); + OUTPUT: + RETVAL + +speed_t +cfgetispeed(termios_ref) + POSIX::Termios termios_ref + +speed_t +cfgetospeed(termios_ref) + POSIX::Termios termios_ref + +tcflag_t +getiflag(termios_ref) + POSIX::Termios termios_ref + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + RETVAL = termios_ref->c_iflag; +#else + not_here("getiflag"); + RETVAL = 0; +#endif + OUTPUT: + RETVAL + +tcflag_t +getoflag(termios_ref) + POSIX::Termios termios_ref + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + RETVAL = termios_ref->c_oflag; +#else + not_here("getoflag"); + RETVAL = 0; +#endif + OUTPUT: + RETVAL + +tcflag_t +getcflag(termios_ref) + POSIX::Termios termios_ref + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + RETVAL = termios_ref->c_cflag; +#else + not_here("getcflag"); + RETVAL = 0; +#endif + OUTPUT: + RETVAL + +tcflag_t +getlflag(termios_ref) + POSIX::Termios termios_ref + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + RETVAL = termios_ref->c_lflag; +#else + not_here("getlflag"); + RETVAL = 0; +#endif + OUTPUT: + RETVAL + +cc_t +getcc(termios_ref, ccix) + POSIX::Termios termios_ref + int ccix + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + if (ccix >= NCCS) + croak("Bad getcc subscript"); + RETVAL = termios_ref->c_cc[ccix]; +#else + not_here("getcc"); + RETVAL = 0; +#endif + OUTPUT: + RETVAL + +SysRet +cfsetispeed(termios_ref, speed) + POSIX::Termios termios_ref + speed_t speed + +SysRet +cfsetospeed(termios_ref, speed) + POSIX::Termios termios_ref + speed_t speed + +void +setiflag(termios_ref, iflag) + POSIX::Termios termios_ref + tcflag_t iflag + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + termios_ref->c_iflag = iflag; +#else + not_here("setiflag"); +#endif + +void +setoflag(termios_ref, oflag) + POSIX::Termios termios_ref + tcflag_t oflag + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + termios_ref->c_oflag = oflag; +#else + not_here("setoflag"); +#endif + +void +setcflag(termios_ref, cflag) + POSIX::Termios termios_ref + tcflag_t cflag + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + termios_ref->c_cflag = cflag; +#else + not_here("setcflag"); +#endif + +void +setlflag(termios_ref, lflag) + POSIX::Termios termios_ref + tcflag_t lflag + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + termios_ref->c_lflag = lflag; +#else + not_here("setlflag"); +#endif + +void +setcc(termios_ref, ccix, cc) + POSIX::Termios termios_ref + int ccix + cc_t cc + CODE: +#ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */ + if (ccix >= NCCS) + croak("Bad setcc subscript"); + termios_ref->c_cc[ccix] = cc; +#else + not_here("setcc"); +#endif + + +MODULE = POSIX PACKAGE = POSIX + +double +constant(name,arg) + char * name + int arg + +int +isalnum(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isalnum(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isalpha(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isalpha(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +iscntrl(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!iscntrl(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isdigit(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isdigit(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isgraph(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isgraph(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +islower(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!islower(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isprint(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isprint(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +ispunct(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!ispunct(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isspace(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isspace(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isupper(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isupper(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +int +isxdigit(charstring) + unsigned char * charstring + CODE: + unsigned char *s = charstring; + unsigned char *e = s + PL_na; /* "PL_na" set by typemap side effect */ + for (RETVAL = 1; RETVAL && s < e; s++) + if (!isxdigit(*s)) + RETVAL = 0; + OUTPUT: + RETVAL + +SysRet +open(filename, flags = O_RDONLY, mode = 0666) + char * filename + int flags + Mode_t mode + CODE: + if (flags & (O_APPEND|O_CREAT|O_TRUNC|O_RDWR|O_WRONLY|O_EXCL)) + TAINT_PROPER("open"); + RETVAL = open(filename, flags, mode); + OUTPUT: + RETVAL + + +HV * +localeconv() + CODE: +#ifdef HAS_LOCALECONV + struct lconv *lcbuf; + RETVAL = newHV(); + if (lcbuf = localeconv()) { + /* the strings */ + if (lcbuf->decimal_point && *lcbuf->decimal_point) + hv_store(RETVAL, "decimal_point", 13, + newSVpv(lcbuf->decimal_point, 0), 0); + if (lcbuf->thousands_sep && *lcbuf->thousands_sep) + hv_store(RETVAL, "thousands_sep", 13, + newSVpv(lcbuf->thousands_sep, 0), 0); +#ifndef NO_LOCALECONV_GROUPING + if (lcbuf->grouping && *lcbuf->grouping) + hv_store(RETVAL, "grouping", 8, + newSVpv(lcbuf->grouping, 0), 0); +#endif + if (lcbuf->int_curr_symbol && *lcbuf->int_curr_symbol) + hv_store(RETVAL, "int_curr_symbol", 15, + newSVpv(lcbuf->int_curr_symbol, 0), 0); + if (lcbuf->currency_symbol && *lcbuf->currency_symbol) + hv_store(RETVAL, "currency_symbol", 15, + newSVpv(lcbuf->currency_symbol, 0), 0); + if (lcbuf->mon_decimal_point && *lcbuf->mon_decimal_point) + hv_store(RETVAL, "mon_decimal_point", 17, + newSVpv(lcbuf->mon_decimal_point, 0), 0); +#ifndef NO_LOCALECONV_MON_THOUSANDS_SEP + if (lcbuf->mon_thousands_sep && *lcbuf->mon_thousands_sep) + hv_store(RETVAL, "mon_thousands_sep", 17, + newSVpv(lcbuf->mon_thousands_sep, 0), 0); +#endif +#ifndef NO_LOCALECONV_MON_GROUPING + if (lcbuf->mon_grouping && *lcbuf->mon_grouping) + hv_store(RETVAL, "mon_grouping", 12, + newSVpv(lcbuf->mon_grouping, 0), 0); +#endif + if (lcbuf->positive_sign && *lcbuf->positive_sign) + hv_store(RETVAL, "positive_sign", 13, + newSVpv(lcbuf->positive_sign, 0), 0); + if (lcbuf->negative_sign && *lcbuf->negative_sign) + hv_store(RETVAL, "negative_sign", 13, + newSVpv(lcbuf->negative_sign, 0), 0); + /* the integers */ + if (lcbuf->int_frac_digits != CHAR_MAX) + hv_store(RETVAL, "int_frac_digits", 15, + newSViv(lcbuf->int_frac_digits), 0); + if (lcbuf->frac_digits != CHAR_MAX) + hv_store(RETVAL, "frac_digits", 11, + newSViv(lcbuf->frac_digits), 0); + if (lcbuf->p_cs_precedes != CHAR_MAX) + hv_store(RETVAL, "p_cs_precedes", 13, + newSViv(lcbuf->p_cs_precedes), 0); + if (lcbuf->p_sep_by_space != CHAR_MAX) + hv_store(RETVAL, "p_sep_by_space", 14, + newSViv(lcbuf->p_sep_by_space), 0); + if (lcbuf->n_cs_precedes != CHAR_MAX) + hv_store(RETVAL, "n_cs_precedes", 13, + newSViv(lcbuf->n_cs_precedes), 0); + if (lcbuf->n_sep_by_space != CHAR_MAX) + hv_store(RETVAL, "n_sep_by_space", 14, + newSViv(lcbuf->n_sep_by_space), 0); + if (lcbuf->p_sign_posn != CHAR_MAX) + hv_store(RETVAL, "p_sign_posn", 11, + newSViv(lcbuf->p_sign_posn), 0); + if (lcbuf->n_sign_posn != CHAR_MAX) + hv_store(RETVAL, "n_sign_posn", 11, + newSViv(lcbuf->n_sign_posn), 0); + } +#else + localeconv(); /* A stub to call not_here(). */ +#endif + OUTPUT: + RETVAL + +char * +setlocale(category, locale = 0) + int category + char * locale + CODE: + RETVAL = setlocale(category, locale); + if (RETVAL) { +#ifdef USE_LOCALE_CTYPE + if (category == LC_CTYPE +#ifdef LC_ALL + || category == LC_ALL +#endif + ) + { + char *newctype; +#ifdef LC_ALL + if (category == LC_ALL) + newctype = setlocale(LC_CTYPE, NULL); + else +#endif + newctype = RETVAL; + perl_new_ctype(newctype); + } +#endif /* USE_LOCALE_CTYPE */ +#ifdef USE_LOCALE_COLLATE + if (category == LC_COLLATE +#ifdef LC_ALL + || category == LC_ALL +#endif + ) + { + char *newcoll; +#ifdef LC_ALL + if (category == LC_ALL) + newcoll = setlocale(LC_COLLATE, NULL); + else +#endif + newcoll = RETVAL; + perl_new_collate(newcoll); + } +#endif /* USE_LOCALE_COLLATE */ +#ifdef USE_LOCALE_NUMERIC + if (category == LC_NUMERIC +#ifdef LC_ALL + || category == LC_ALL +#endif + ) + { + char *newnum; +#ifdef LC_ALL + if (category == LC_ALL) + newnum = setlocale(LC_NUMERIC, NULL); + else +#endif + newnum = RETVAL; + perl_new_numeric(newnum); + } +#endif /* USE_LOCALE_NUMERIC */ + } + OUTPUT: + RETVAL + + +double +acos(x) + double x + +double +asin(x) + double x + +double +atan(x) + double x + +double +ceil(x) + double x + +double +cosh(x) + double x + +double +floor(x) + double x + +double +fmod(x,y) + double x + double y + +void +frexp(x) + double x + PPCODE: + int expvar; + /* (We already know stack is long enough.) */ + PUSHs(sv_2mortal(newSVnv(frexp(x,&expvar)))); + PUSHs(sv_2mortal(newSViv(expvar))); + +double +ldexp(x,exp) + double x + int exp + +double +log10(x) + double x + +void +modf(x) + double x + PPCODE: + double intvar; + /* (We already know stack is long enough.) */ + PUSHs(sv_2mortal(newSVnv(modf(x,&intvar)))); + PUSHs(sv_2mortal(newSVnv(intvar))); + +double +sinh(x) + double x + +double +tan(x) + double x + +double +tanh(x) + double x + +SysRet +sigaction(sig, action, oldaction = 0) + int sig + POSIX::SigAction action + POSIX::SigAction oldaction + CODE: +#ifdef WIN32 + RETVAL = not_here("sigaction"); +#else +# This code is really grody because we're trying to make the signal +# interface look beautiful, which is hard. + + if (!PL_siggv) + gv_fetchpv("SIG", TRUE, SVt_PVHV); + + { + struct sigaction act; + struct sigaction oact; + POSIX__SigSet sigset; + SV** svp; + SV** sigsvp = hv_fetch(GvHVn(PL_siggv), + sig_name[sig], + strlen(sig_name[sig]), + TRUE); + + /* Remember old handler name if desired. */ + if (oldaction) { + char *hand = SvPVx(*sigsvp, PL_na); + svp = hv_fetch(oldaction, "HANDLER", 7, TRUE); + sv_setpv(*svp, *hand ? hand : "DEFAULT"); + } + + if (action) { + /* Vector new handler through %SIG. (We always use sighandler + for the C signal handler, which reads %SIG to dispatch.) */ + svp = hv_fetch(action, "HANDLER", 7, FALSE); + if (!svp) + croak("Can't supply an action without a HANDLER"); + sv_setpv(*sigsvp, SvPV(*svp, PL_na)); + mg_set(*sigsvp); /* handles DEFAULT and IGNORE */ + act.sa_handler = sighandler; + + /* Set up any desired mask. */ + svp = hv_fetch(action, "MASK", 4, FALSE); + if (svp && sv_isa(*svp, "POSIX::SigSet")) { + unsigned long tmp; + tmp = (unsigned long)SvNV((SV*)SvRV(*svp)); + sigset = (sigset_t*) tmp; + act.sa_mask = *sigset; + } + else + sigemptyset(& act.sa_mask); + + /* Set up any desired flags. */ + svp = hv_fetch(action, "FLAGS", 5, FALSE); + act.sa_flags = svp ? SvIV(*svp) : 0; + } + + /* Now work around sigaction oddities */ + if (action && oldaction) + RETVAL = sigaction(sig, & act, & oact); + else if (action) + RETVAL = sigaction(sig, & act, (struct sigaction *)0); + else if (oldaction) + RETVAL = sigaction(sig, (struct sigaction *)0, & oact); + else + RETVAL = -1; + + if (oldaction) { + /* Get back the mask. */ + svp = hv_fetch(oldaction, "MASK", 4, TRUE); + if (sv_isa(*svp, "POSIX::SigSet")) { + unsigned long tmp; + tmp = (unsigned long)SvNV((SV*)SvRV(*svp)); + sigset = (sigset_t*) tmp; + } + else { + sigset = (sigset_t*)safemalloc(sizeof(sigset_t)); + sv_setptrobj(*svp, sigset, "POSIX::SigSet"); + } + *sigset = oact.sa_mask; + + /* Get back the flags. */ + svp = hv_fetch(oldaction, "FLAGS", 5, TRUE); + sv_setiv(*svp, oact.sa_flags); + } + } +#endif + OUTPUT: + RETVAL + +SysRet +sigpending(sigset) + POSIX::SigSet sigset + +SysRet +sigprocmask(how, sigset, oldsigset = 0) + int how + POSIX::SigSet sigset + POSIX::SigSet oldsigset + +SysRet +sigsuspend(signal_mask) + POSIX::SigSet signal_mask + +void +_exit(status) + int status + +SysRet +close(fd) + int fd + +SysRet +dup(fd) + int fd + +SysRet +dup2(fd1, fd2) + int fd1 + int fd2 + +SysRetLong +lseek(fd, offset, whence) + int fd + Off_t offset + int whence + +SysRet +nice(incr) + int incr + +int +pipe() + PPCODE: + int fds[2]; + if (pipe(fds) != -1) { + EXTEND(SP,2); + PUSHs(sv_2mortal(newSViv(fds[0]))); + PUSHs(sv_2mortal(newSViv(fds[1]))); + } + +SysRet +read(fd, buffer, nbytes) + PREINIT: + SV *sv_buffer = SvROK(ST(1)) ? SvRV(ST(1)) : ST(1); + INPUT: + int fd + size_t nbytes + char * buffer = sv_grow( sv_buffer, nbytes+1 ); + CLEANUP: + if (RETVAL >= 0) { + SvCUR(sv_buffer) = RETVAL; + SvPOK_only(sv_buffer); + *SvEND(sv_buffer) = '\0'; + SvTAINTED_on(sv_buffer); + } + +SysRet +setpgid(pid, pgid) + pid_t pid + pid_t pgid + +pid_t +setsid() + +pid_t +tcgetpgrp(fd) + int fd + +SysRet +tcsetpgrp(fd, pgrp_id) + int fd + pid_t pgrp_id + +int +uname() + PPCODE: +#ifdef HAS_UNAME + struct utsname buf; + if (uname(&buf) >= 0) { + EXTEND(SP, 5); + PUSHs(sv_2mortal(newSVpv(buf.sysname, 0))); + PUSHs(sv_2mortal(newSVpv(buf.nodename, 0))); + PUSHs(sv_2mortal(newSVpv(buf.release, 0))); + PUSHs(sv_2mortal(newSVpv(buf.version, 0))); + PUSHs(sv_2mortal(newSVpv(buf.machine, 0))); + } +#else + uname((char *) 0); /* A stub to call not_here(). */ +#endif + +SysRet +write(fd, buffer, nbytes) + int fd + char * buffer + size_t nbytes + +char * +tmpnam(s = 0) + char * s = 0; + +void +abort() + +int +mblen(s, n) + char * s + size_t n + +size_t +mbstowcs(s, pwcs, n) + wchar_t * s + char * pwcs + size_t n + +int +mbtowc(pwc, s, n) + wchar_t * pwc + char * s + size_t n + +int +wcstombs(s, pwcs, n) + char * s + wchar_t * pwcs + size_t n + +int +wctomb(s, wchar) + char * s + wchar_t wchar + +int +strcoll(s1, s2) + char * s1 + char * s2 + +void +strtod(str) + char * str + PREINIT: + double num; + char *unparsed; + PPCODE: + SET_NUMERIC_LOCAL(); + num = strtod(str, &unparsed); + PUSHs(sv_2mortal(newSVnv(num))); + if (GIMME == G_ARRAY) { + EXTEND(SP, 1); + if (unparsed) + PUSHs(sv_2mortal(newSViv(strlen(unparsed)))); + else + PUSHs(&PL_sv_undef); + } + +void +strtol(str, base = 0) + char * str + int base + PREINIT: + long num; + char *unparsed; + PPCODE: + num = strtol(str, &unparsed, base); + if (num >= IV_MIN && num <= IV_MAX) + PUSHs(sv_2mortal(newSViv((IV)num))); + else + PUSHs(sv_2mortal(newSVnv((double)num))); + if (GIMME == G_ARRAY) { + EXTEND(SP, 1); + if (unparsed) + PUSHs(sv_2mortal(newSViv(strlen(unparsed)))); + else + PUSHs(&PL_sv_undef); + } + +void +strtoul(str, base = 0) + char * str + int base + PREINIT: + unsigned long num; + char *unparsed; + PPCODE: + num = strtoul(str, &unparsed, base); + if (num <= IV_MAX) + PUSHs(sv_2mortal(newSViv((IV)num))); + else + PUSHs(sv_2mortal(newSVnv((double)num))); + if (GIMME == G_ARRAY) { + EXTEND(SP, 1); + if (unparsed) + PUSHs(sv_2mortal(newSViv(strlen(unparsed)))); + else + PUSHs(&PL_sv_undef); + } + +SV * +strxfrm(src) + SV * src + CODE: + { + STRLEN srclen; + STRLEN dstlen; + char *p = SvPV(src,srclen); + srclen++; + ST(0) = sv_2mortal(NEWSV(800,srclen)); + dstlen = strxfrm(SvPVX(ST(0)), p, (size_t)srclen); + if (dstlen > srclen) { + dstlen++; + SvGROW(ST(0), dstlen); + strxfrm(SvPVX(ST(0)), p, (size_t)dstlen); + dstlen--; + } + SvCUR(ST(0)) = dstlen; + SvPOK_only(ST(0)); + } + +SysRet +mkfifo(filename, mode) + char * filename + Mode_t mode + CODE: + TAINT_PROPER("mkfifo"); + RETVAL = mkfifo(filename, mode); + OUTPUT: + RETVAL + +SysRet +tcdrain(fd) + int fd + + +SysRet +tcflow(fd, action) + int fd + int action + + +SysRet +tcflush(fd, queue_selector) + int fd + int queue_selector + +SysRet +tcsendbreak(fd, duration) + int fd + int duration + +char * +asctime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0) + int sec + int min + int hour + int mday + int mon + int year + int wday + int yday + int isdst + CODE: + { + struct tm mytm; + init_tm(&mytm); /* XXX workaround - see init_tm() above */ + mytm.tm_sec = sec; + mytm.tm_min = min; + mytm.tm_hour = hour; + mytm.tm_mday = mday; + mytm.tm_mon = mon; + mytm.tm_year = year; + mytm.tm_wday = wday; + mytm.tm_yday = yday; + mytm.tm_isdst = isdst; + RETVAL = asctime(&mytm); + } + OUTPUT: + RETVAL + +long +clock() + +char * +ctime(time) + Time_t &time + +void +times() + PPCODE: + struct tms tms; + clock_t realtime; + realtime = times( &tms ); + EXTEND(SP,5); + PUSHs( sv_2mortal( newSViv( (IV) realtime ) ) ); + PUSHs( sv_2mortal( newSViv( (IV) tms.tms_utime ) ) ); + PUSHs( sv_2mortal( newSViv( (IV) tms.tms_stime ) ) ); + PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cutime ) ) ); + PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cstime ) ) ); + +double +difftime(time1, time2) + Time_t time1 + Time_t time2 + +SysRetLong +mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0) + int sec + int min + int hour + int mday + int mon + int year + int wday + int yday + int isdst + CODE: + { + struct tm mytm; + init_tm(&mytm); /* XXX workaround - see init_tm() above */ + mytm.tm_sec = sec; + mytm.tm_min = min; + mytm.tm_hour = hour; + mytm.tm_mday = mday; + mytm.tm_mon = mon; + mytm.tm_year = year; + mytm.tm_wday = wday; + mytm.tm_yday = yday; + mytm.tm_isdst = isdst; + RETVAL = mktime(&mytm); + } + OUTPUT: + RETVAL + +char * +strftime(fmt, sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0) + char * fmt + int sec + int min + int hour + int mday + int mon + int year + int wday + int yday + int isdst + CODE: + { + char tmpbuf[128]; + struct tm mytm; + int len; + init_tm(&mytm); /* XXX workaround - see init_tm() above */ + mytm.tm_sec = sec; + mytm.tm_min = min; + mytm.tm_hour = hour; + mytm.tm_mday = mday; + mytm.tm_mon = mon; + mytm.tm_year = year; + mytm.tm_wday = wday; + mytm.tm_yday = yday; + mytm.tm_isdst = isdst; + len = strftime(tmpbuf, sizeof tmpbuf, fmt, &mytm); + ST(0) = sv_2mortal(newSVpv(tmpbuf, len)); + } + +void +tzset() + +void +tzname() + PPCODE: + EXTEND(SP,2); + PUSHs(sv_2mortal(newSVpv(tzname[0],strlen(tzname[0])))); + PUSHs(sv_2mortal(newSVpv(tzname[1],strlen(tzname[1])))); + +SysRet +access(filename, mode) + char * filename + Mode_t mode + +char * +ctermid(s = 0) + char * s = 0; + +char * +cuserid(s = 0) + char * s = 0; + +SysRetLong +fpathconf(fd, name) + int fd + int name + +SysRetLong +pathconf(filename, name) + char * filename + int name + +SysRet +pause() + +SysRetLong +sysconf(name) + int name + +char * +ttyname(fd) + int fd diff --git a/contrib/perl5/ext/POSIX/hints/bsdos.pl b/contrib/perl5/ext/POSIX/hints/bsdos.pl new file mode 100644 index 0000000..62732ac --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/bsdos.pl @@ -0,0 +1,3 @@ +# BSD platforms have extra fields in struct tm that need to be initialized. +# XXX A Configure test is needed. +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE' ; diff --git a/contrib/perl5/ext/POSIX/hints/freebsd.pl b/contrib/perl5/ext/POSIX/hints/freebsd.pl new file mode 100644 index 0000000..62732ac --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/freebsd.pl @@ -0,0 +1,3 @@ +# BSD platforms have extra fields in struct tm that need to be initialized. +# XXX A Configure test is needed. +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE' ; diff --git a/contrib/perl5/ext/POSIX/hints/linux.pl b/contrib/perl5/ext/POSIX/hints/linux.pl new file mode 100644 index 0000000..f1d1981 --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/linux.pl @@ -0,0 +1,5 @@ +# libc6, aka glibc2, seems to need STRUCT_TM_HASZONE defined. +# Thanks to Bart Schuller <schuller@Lunatech.com> +# See Message-ID: <19971009002636.50729@tanglefoot> +# XXX A Configure test is needed. +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE -DHINT_SC_EXIST' ; diff --git a/contrib/perl5/ext/POSIX/hints/netbsd.pl b/contrib/perl5/ext/POSIX/hints/netbsd.pl new file mode 100644 index 0000000..62732ac --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/netbsd.pl @@ -0,0 +1,3 @@ +# BSD platforms have extra fields in struct tm that need to be initialized. +# XXX A Configure test is needed. +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE' ; diff --git a/contrib/perl5/ext/POSIX/hints/next_3.pl b/contrib/perl5/ext/POSIX/hints/next_3.pl new file mode 100644 index 0000000..d907783 --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/next_3.pl @@ -0,0 +1,5 @@ +# NeXT *does* have setpgid when we use the -posix flag, but +# doesn't when we don't. The main perl sources are compiled +# without -posix, so the hints/next_3.sh hint file tells Configure +# that d_setpgid=undef. +$self->{CCFLAGS} = $Config{ccflags} . ' -posix -DHAS_SETPGID' ; diff --git a/contrib/perl5/ext/POSIX/hints/openbsd.pl b/contrib/perl5/ext/POSIX/hints/openbsd.pl new file mode 100644 index 0000000..62732ac --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/openbsd.pl @@ -0,0 +1,3 @@ +# BSD platforms have extra fields in struct tm that need to be initialized. +# XXX A Configure test is needed. +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE' ; diff --git a/contrib/perl5/ext/POSIX/hints/sunos_4.pl b/contrib/perl5/ext/POSIX/hints/sunos_4.pl new file mode 100644 index 0000000..32b3558 --- /dev/null +++ b/contrib/perl5/ext/POSIX/hints/sunos_4.pl @@ -0,0 +1,10 @@ +# SunOS 4.1.3 has two extra fields in struct tm. This works around +# the problem. Other BSD platforms may have similar problems. +# This state of affairs also persists in glibc2, found +# on linux systems running libc6. +# XXX A Configure test is needed. + +# Although <unistd.h> is inappropriate in general for SunOS, we need it +# in POSIX.xs to get the correct prototype for ttyname(). + +$self->{CCFLAGS} = $Config{ccflags} . ' -DSTRUCT_TM_HASZONE -DI_UNISTD' ; diff --git a/contrib/perl5/ext/POSIX/typemap b/contrib/perl5/ext/POSIX/typemap new file mode 100644 index 0000000..63e41c7 --- /dev/null +++ b/contrib/perl5/ext/POSIX/typemap @@ -0,0 +1,14 @@ +Mode_t T_NV +pid_t T_NV +Uid_t T_NV +Time_t T_NV +Gid_t T_NV +Off_t T_NV +Dev_t T_NV +fd T_IV +speed_t T_IV +tcflag_t T_IV +cc_t T_IV +POSIX::SigSet T_PTROBJ +POSIX::Termios T_PTROBJ +POSIX::SigAction T_HVREF |
