ext/POSIX/POSIX.xs

   1 #define PERL_EXT_POSIX
   2
   3 #ifdef WIN32
   4 #define _POSIX_
   5 #endif
   6
   7 #ifdef NETWARE
   8         #define _POSIX_
   9         /*
  10          * Ideally this should be somewhere down in the includes
  11          * but putting it in other places is giving compiler errors.
  12          * Also here I am unable to check for HAS_UNAME since it wouldn't have
  13          * yet come into the file at this stage - sgp 18th Oct 2000
  14          */
  15         #include <sys/utsname.h>
  16 #endif  /* NETWARE */
  17
  18 #define PERL_NO_GET_CONTEXT
  19
  20 #include "EXTERN.h"
  21 #define PERLIO_NOT_STDIO 1
  22 #include "perl.h"
  23 #include "XSUB.h"
  24 #if defined(PERL_IMPLICIT_SYS)
  25 #  undef signal
  26 #  undef open
  27 #  undef setmode
  28 #  define open PerlLIO_open3
  29 #endif
  30 #include <ctype.h>
  31 #ifdef I_DIRENT    /* XXX maybe better to just rely on perl.h? */
  32 #include <dirent.h>
  33 #endif
  34 #include <errno.h>
  35 #ifdef I_FLOAT
  36 #include <float.h>
  37 #endif
  38 #ifdef I_LIMITS
  39 #include <limits.h>
  40 #endif
  41 #include <locale.h>
  42 #include <math.h>
  43 #ifdef I_PWD
  44 #include <pwd.h>
  45 #endif
  46 #include <setjmp.h>
  47 #include <signal.h>
  48 #include <stdarg.h>
  49
  50 #ifdef I_STDDEF
  51 #include <stddef.h>
  52 #endif
  53
  54 #ifdef I_UNISTD
  55 #include <unistd.h>
  56 #endif
  57
  58 /* XXX This comment is just to make I_TERMIO and I_SGTTY visible to
  59    metaconfig for future extension writers.  We don't use them in POSIX.
  60    (This is really sneaky :-)  --AD
  61 */
  62 #if defined(I_TERMIOS)
  63 #include <termios.h>
  64 #endif
  65 #ifdef I_STDLIB
  66 #include <stdlib.h>
  67 #endif
  68 #include <string.h>
  69 #include <sys/stat.h>
  70 #include <sys/types.h>
  71 #include <time.h>
  72 #ifdef I_UNISTD
  73 #include <unistd.h>
  74 #endif
  75 #ifdef MACOS_TRADITIONAL
  76 #undef fdopen
  77 #endif
  78 #include <fcntl.h>
  79
  80 #ifdef HAS_TZNAME
  81 #  if !defined(WIN32) && !defined(__CYGWIN__) && !defined(NETWARE)
  82 extern char *tzname[];
  83 #  endif
  84 #else
  85 #if !defined(WIN32) || (defined(__MINGW32__) && !defined(tzname))
  86 char *tzname[] = { "" , "" };
  87 #endif
  88 #endif
  89
  90 #if defined(__VMS) && !defined(__POSIX_SOURCE)
  91 #  include <libdef.h>       /* LIB$_INVARG constant */
  92 #  include <lib$routines.h> /* prototype for lib$ediv() */
  93 #  include <starlet.h>      /* prototype for sys$gettim() */
  94 #  if DECC_VERSION < 50000000
  95 #    define pid_t int       /* old versions of DECC miss this in types.h */
  96 #  endif
  97
  98 #  undef mkfifo
  99 #  define mkfifo(a,b) (not_here("mkfifo"),-1)
 100 #  define tzset() not_here("tzset")
 101
 102 #if ((__VMS_VER >= 70000000) && (__DECC_VER >= 50200000)) || (__CRTL_VER >= 70000000)
 103 #    define HAS_TZNAME  /* shows up in VMS 7.0 or Dec C 5.6 */
 104 #    include <utsname.h>
 105 #  endif /* __VMS_VER >= 70000000 or Dec C 5.6 */
 106
 107    /* The POSIX notion of ttyname() is better served by getname() under VMS */
 108    static char ttnambuf[64];
 109 #  define ttyname(fd) (isatty(fd) > 0 ? getname(fd,ttnambuf,0) : NULL)
 110
 111    /* The non-POSIX CRTL times() has void return type, so we just get the
 112       current time directly */
 113    clock_t vms_times(struct tms *bufptr) {
 114         dTHX;
 115         clock_t retval;
 116         /* Get wall time and convert to 10 ms intervals to
 117          * produce the return value that the POSIX standard expects */
 118 #  if defined(__DECC) && defined (__ALPHA)
 119 #    include <ints.h>
 120         uint64 vmstime;
 121         _ckvmssts(sys$gettim(&vmstime));
 122         vmstime /= 100000;
 123         retval = vmstime & 0x7fffffff;
 124 #  else
 125         /* (Older hw or ccs don't have an atomic 64-bit type, so we
 126          * juggle 32-bit ints (and a float) to produce a time_t result
 127          * with minimal loss of information.) */
 128         long int vmstime[2],remainder,divisor = 100000;
 129         _ckvmssts(sys$gettim((unsigned long int *)vmstime));
 130         vmstime[1] &= 0x7fff;  /* prevent overflow in EDIV */
 131         _ckvmssts(lib$ediv(&divisor,vmstime,(long int *)&retval,&remainder));
 132 #  endif
 133         /* Fill in the struct tms using the CRTL routine . . .*/
 134         times((tbuffer_t *)bufptr);
 135         return (clock_t) retval;
 136    }
 137 #  define times(t) vms_times(t)
 138 #else
 139 #if defined (__CYGWIN__)
 140 #    define tzname _tzname
 141 #endif
 142 #if defined (WIN32) || defined (NETWARE)
 143 #  undef mkfifo
 144 #  define mkfifo(a,b) not_here("mkfifo")
 145 #  define ttyname(a) (char*)not_here("ttyname")
 146 #  define sigset_t long
 147 #  define pid_t long
 148 #  ifdef __BORLANDC__
 149 #    define tzname _tzname
 150 #  endif
 151 #  ifdef _MSC_VER
 152 #    define mode_t short
 153 #  endif
 154 #  ifdef __MINGW32__
 155 #    define mode_t short
 156 #    ifndef tzset
 157 #      define tzset()           not_here("tzset")
 158 #    endif
 159 #    ifndef _POSIX_OPEN_MAX
 160 #      define _POSIX_OPEN_MAX   FOPEN_MAX       /* XXX bogus ? */
 161 #    endif
 162 #  endif
 163 #  define sigaction(a,b,c)      not_here("sigaction")
 164 #  define sigpending(a)         not_here("sigpending")
 165 #  define sigprocmask(a,b,c)    not_here("sigprocmask")
 166 #  define sigsuspend(a)         not_here("sigsuspend")
 167 #  define sigemptyset(a)        not_here("sigemptyset")
 168 #  define sigaddset(a,b)        not_here("sigaddset")
 169 #  define sigdelset(a,b)        not_here("sigdelset")
 170 #  define sigfillset(a)         not_here("sigfillset")
 171 #  define sigismember(a,b)      not_here("sigismember")
 172 #ifndef NETWARE
 173 #  undef setuid
 174 #  undef setgid
 175 #  define setuid(a)             not_here("setuid")
 176 #  define setgid(a)             not_here("setgid")
 177 #endif  /* NETWARE */
 178 #else
 179
 180 #  ifndef HAS_MKFIFO
 181 #    if defined(OS2) || defined(MACOS_TRADITIONAL)
 182 #      define mkfifo(a,b) not_here("mkfifo")
 183 #    else       /* !( defined OS2 ) */
 184 #      ifndef mkfifo
 185 #        define mkfifo(path, mode) (mknod((path), (mode) | S_IFIFO, 0))
 186 #      endif
 187 #    endif
 188 #  endif /* !HAS_MKFIFO */
 189
 190 #  ifdef MACOS_TRADITIONAL
 191 #    define ttyname(a) (char*)not_here("ttyname")
 192 #    define tzset() not_here("tzset")
 193 #  else
 194 #    include <grp.h>
 195 #    include <sys/times.h>
 196 #    ifdef HAS_UNAME
 197 #      include <sys/utsname.h>
 198 #    endif
 199 #    include <sys/wait.h>
 200 #  endif
 201 #  ifdef I_UTIME
 202 #    include <utime.h>
 203 #  endif
 204 #endif /* WIN32 || NETWARE */
 205 #endif /* __VMS */
 206
 207 typedef int SysRet;
 208 typedef long SysRetLong;
 209 typedef sigset_t* POSIX__SigSet;
 210 typedef HV* POSIX__SigAction;
 211 #ifdef I_TERMIOS
 212 typedef struct termios* POSIX__Termios;
 213 #else /* Define termios types to int, and call not_here for the functions.*/
 214 #define POSIX__Termios int
 215 #define speed_t int
 216 #define tcflag_t int
 217 #define cc_t int
 218 #define cfgetispeed(x) not_here("cfgetispeed")
 219 #define cfgetospeed(x) not_here("cfgetospeed")
 220 #define tcdrain(x) not_here("tcdrain")
 221 #define tcflush(x,y) not_here("tcflush")
 222 #define tcsendbreak(x,y) not_here("tcsendbreak")
 223 #define cfsetispeed(x,y) not_here("cfsetispeed")
 224 #define cfsetospeed(x,y) not_here("cfsetospeed")
 225 #define ctermid(x) (char *) not_here("ctermid")
 226 #define tcflow(x,y) not_here("tcflow")
 227 #define tcgetattr(x,y) not_here("tcgetattr")
 228 #define tcsetattr(x,y,z) not_here("tcsetattr")
 229 #endif
 230
 231 /* Possibly needed prototypes */
 232 char *cuserid (char *);
 233 #ifndef WIN32
 234 double strtod (const char *, char **);
 235 long strtol (const char *, char **, int);
 236 unsigned long strtoul (const char *, char **, int);
 237 #endif
 238
 239 #ifndef HAS_CUSERID
 240 #define cuserid(a) (char *) not_here("cuserid")
 241 #endif
 242 #ifndef HAS_DIFFTIME
 243 #ifndef difftime
 244 #define difftime(a,b) not_here("difftime")
 245 #endif
 246 #endif
 247 #ifndef HAS_FPATHCONF
 248 #define fpathconf(f,n)  (SysRetLong) not_here("fpathconf")
 249 #endif
 250 #ifndef HAS_MKTIME
 251 #define mktime(a) not_here("mktime")
 252 #endif
 253 #ifndef HAS_NICE
 254 #define nice(a) not_here("nice")
 255 #endif
 256 #ifndef HAS_PATHCONF
 257 #define pathconf(f,n)   (SysRetLong) not_here("pathconf")
 258 #endif
 259 #ifndef HAS_SYSCONF
 260 #define sysconf(n)      (SysRetLong) not_here("sysconf")
 261 #endif
 262 #ifndef HAS_READLINK
 263 #define readlink(a,b,c) not_here("readlink")
 264 #endif
 265 #ifndef HAS_SETPGID
 266 #define setpgid(a,b) not_here("setpgid")
 267 #endif
 268 #ifndef HAS_SETSID
 269 #define setsid() not_here("setsid")
 270 #endif
 271 #ifndef HAS_STRCOLL
 272 #define strcoll(s1,s2) not_here("strcoll")
 273 #endif
 274 #ifndef HAS_STRTOD
 275 #define strtod(s1,s2) not_here("strtod")
 276 #endif
 277 #ifndef HAS_STRTOL
 278 #define strtol(s1,s2,b) not_here("strtol")
 279 #endif
 280 #ifndef HAS_STRTOUL
 281 #define strtoul(s1,s2,b) not_here("strtoul")
 282 #endif
 283 #ifndef HAS_STRXFRM
 284 #define strxfrm(s1,s2,n) not_here("strxfrm")
 285 #endif
 286 #ifndef HAS_TCGETPGRP
 287 #define tcgetpgrp(a) not_here("tcgetpgrp")
 288 #endif
 289 #ifndef HAS_TCSETPGRP
 290 #define tcsetpgrp(a,b) not_here("tcsetpgrp")
 291 #endif
 292 #ifndef HAS_TIMES
 293 #ifndef NETWARE
 294 #define times(a) not_here("times")
 295 #endif  /* NETWARE */
 296 #endif
 297 #ifndef HAS_UNAME
 298 #define uname(a) not_here("uname")
 299 #endif
 300 #ifndef HAS_WAITPID
 301 #define waitpid(a,b,c) not_here("waitpid")
 302 #endif
 303
 304 #ifndef HAS_MBLEN
 305 #ifndef mblen
 306 #define mblen(a,b) not_here("mblen")
 307 #endif
 308 #endif
 309 #ifndef HAS_MBSTOWCS
 310 #define mbstowcs(s, pwcs, n) not_here("mbstowcs")
 311 #endif
 312 #ifndef HAS_MBTOWC
 313 #define mbtowc(pwc, s, n) not_here("mbtowc")
 314 #endif
 315 #ifndef HAS_WCSTOMBS
 316 #define wcstombs(s, pwcs, n) not_here("wcstombs")
 317 #endif
 318 #ifndef HAS_WCTOMB
 319 #define wctomb(s, wchar) not_here("wcstombs")
 320 #endif
 321 #if !defined(HAS_MBLEN) && !defined(HAS_MBSTOWCS) && !defined(HAS_MBTOWC) && !defined(HAS_WCSTOMBS) && !defined(HAS_WCTOMB)
 322 /* If we don't have these functions, then we wouldn't have gotten a typedef
 323    for wchar_t, the wide character type.  Defining wchar_t allows the
 324    functions referencing it to compile.  Its actual type is then meaningless,
 325    since without the above functions, all sections using it end up calling
 326    not_here() and croak.  --Kaveh Ghazi (ghazi@noc.rutgers.edu) 9/18/94. */
 327 #ifndef wchar_t
 328 #define wchar_t char
 329 #endif
 330 #endif
 331
 332 #ifndef HAS_LOCALECONV
 333 #define localeconv() not_here("localeconv")
 334 #endif
 335
 336 #ifdef HAS_LONG_DOUBLE
 337 #  if LONG_DOUBLESIZE > NVSIZE
 338 #    undef HAS_LONG_DOUBLE  /* XXX until we figure out how to use them */
 339 #  endif
 340 #endif
 341
 342 #ifndef HAS_LONG_DOUBLE
 343 #ifdef LDBL_MAX
 344 #undef LDBL_MAX
 345 #endif
 346 #ifdef LDBL_MIN
 347 #undef LDBL_MIN
 348 #endif
 349 #ifdef LDBL_EPSILON
 350 #undef LDBL_EPSILON
 351 #endif
 352 #endif
 353
 354 /* Background: in most systems the low byte of the wait status
 355  * is the signal (the lowest 7 bits) and the coredump flag is
 356  * the eight bit, and the second lowest byte is the exit status.
 357  * BeOS bucks the trend and has the bytes in different order.
 358  * See beos/beos.c for how the reality is bent even in BeOS
 359  * to follow the traditional.  However, to make the POSIX
 360  * wait W*() macros to work in BeOS, we need to unbend the
 361  * reality back in place. --jhi */
 362 #ifdef __BEOS__
 363 #    define WMUNGE(x) (((x) & 0xFF00) >> 8 | ((x) & 0x00FF) << 8)
 364 #else
 365 #    define WMUNGE(x) (x)
 366 #endif
 367
 368 static int
 369 not_here(char *s)
 370 {
 371     croak("POSIX::%s not implemented on this architecture", s);
 372     return -1;
 373 }
 374
 375 #include "const-c.inc"
 376
 377 /* These were implemented in the old "constant" subroutine. They are actually
 378    macros that take an integer argument and return an integer result.  */
 379 static int
 380 int_macro_int (const char *name, STRLEN len, IV *arg_result) {
 381   /* Initially switch on the length of the name.  */
 382   /* This code has been edited from a "constant" function generated by:
 383
 384 use ExtUtils::Constant qw (constant_types C_constant XS_constant);
 385
 386 my $types = {map {($_, 1)} qw(IV)};
 387 my @names = (qw(S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG WEXITSTATUS WIFEXITED
 388                WIFSIGNALED WIFSTOPPED WSTOPSIG WTERMSIG));
 389
 390 print constant_types(); # macro defs
 391 foreach (C_constant ("POSIX", 'int_macro_int', 'IV', $types, undef, 5, @names) ) {
 392     print $_, "\n"; # C constant subs
 393 }
 394 print "#### XS Section:\n";
 395 print XS_constant ("POSIX", $types);
 396 __END__
 397    */
 398
 399   switch (len) {
 400   case 7:
 401     /* Names all of length 7.  */
 402     /* S_ISBLK S_ISCHR S_ISDIR S_ISREG */
 403     /* Offset 5 gives the best switch position.  */
 404     switch (name[5]) {
 405     case 'E':
 406       if (memEQ(name, "S_ISREG", 7)) {
 407       /*                    ^       */
 408 #ifdef S_ISREG
 409         *arg_result = S_ISREG(*arg_result);
 410         return PERL_constant_ISIV;
 411 #else
 412         return PERL_constant_NOTDEF;
 413 #endif
 414       }
 415       break;
 416     case 'H':
 417       if (memEQ(name, "S_ISCHR", 7)) {
 418       /*                    ^       */
 419 #ifdef S_ISCHR
 420         *arg_result = S_ISCHR(*arg_result);
 421         return PERL_constant_ISIV;
 422 #else
 423         return PERL_constant_NOTDEF;
 424 #endif
 425       }
 426       break;
 427     case 'I':
 428       if (memEQ(name, "S_ISDIR", 7)) {
 429       /*                    ^       */
 430 #ifdef S_ISDIR
 431         *arg_result = S_ISDIR(*arg_result);
 432         return PERL_constant_ISIV;
 433 #else
 434         return PERL_constant_NOTDEF;
 435 #endif
 436       }
 437       break;
 438     case 'L':
 439       if (memEQ(name, "S_ISBLK", 7)) {
 440       /*                    ^       */
 441 #ifdef S_ISBLK
 442         *arg_result = S_ISBLK(*arg_result);
 443         return PERL_constant_ISIV;
 444 #else
 445         return PERL_constant_NOTDEF;
 446 #endif
 447       }
 448       break;
 449     }
 450     break;
 451   case 8:
 452     /* Names all of length 8.  */
 453     /* S_ISFIFO WSTOPSIG WTERMSIG */
 454     /* Offset 3 gives the best switch position.  */
 455     switch (name[3]) {
 456     case 'O':
 457       if (memEQ(name, "WSTOPSIG", 8)) {
 458       /*                  ^          */
 459 #ifdef WSTOPSIG
 460         *arg_result = WSTOPSIG(WMUNGE(*arg_result));
 461         return PERL_constant_ISIV;
 462 #else
 463         return PERL_constant_NOTDEF;
 464 #endif
 465       }
 466       break;
 467     case 'R':
 468       if (memEQ(name, "WTERMSIG", 8)) {
 469       /*                  ^          */
 470 #ifdef WTERMSIG
 471         *arg_result = WTERMSIG(WMUNGE(*arg_result));
 472         return PERL_constant_ISIV;
 473 #else
 474         return PERL_constant_NOTDEF;
 475 #endif
 476       }
 477       break;
 478     case 'S':
 479       if (memEQ(name, "S_ISFIFO", 8)) {
 480       /*                  ^          */
 481 #ifdef S_ISFIFO
 482         *arg_result = S_ISFIFO(*arg_result);
 483         return PERL_constant_ISIV;
 484 #else
 485         return PERL_constant_NOTDEF;
 486 #endif
 487       }
 488       break;
 489     }
 490     break;
 491   case 9:
 492     if (memEQ(name, "WIFEXITED", 9)) {
 493 #ifdef WIFEXITED
 494       *arg_result = WIFEXITED(WMUNGE(*arg_result));
 495       return PERL_constant_ISIV;
 496 #else
 497       return PERL_constant_NOTDEF;
 498 #endif
 499     }
 500     break;
 501   case 10:
 502     if (memEQ(name, "WIFSTOPPED", 10)) {
 503 #ifdef WIFSTOPPED
 504       *arg_result = WIFSTOPPED(WMUNGE(*arg_result));
 505       return PERL_constant_ISIV;
 506 #else
 507       return PERL_constant_NOTDEF;
 508 #endif
 509     }
 510     break;
 511   case 11:
 512     /* Names all of length 11.  */
 513     /* WEXITSTATUS WIFSIGNALED */
 514     /* Offset 1 gives the best switch position.  */
 515     switch (name[1]) {
 516     case 'E':
 517       if (memEQ(name, "WEXITSTATUS", 11)) {
 518       /*                ^                */
 519 #ifdef WEXITSTATUS
 520         *arg_result = WEXITSTATUS(WMUNGE(*arg_result));
 521         return PERL_constant_ISIV;
 522 #else
 523         return PERL_constant_NOTDEF;
 524 #endif
 525       }
 526       break;
 527     case 'I':
 528       if (memEQ(name, "WIFSIGNALED", 11)) {
 529       /*                ^                */
 530 #ifdef WIFSIGNALED
 531         *arg_result = WIFSIGNALED(WMUNGE(*arg_result));
 532         return PERL_constant_ISIV;
 533 #else
 534         return PERL_constant_NOTDEF;
 535 #endif
 536       }
 537       break;
 538     }
 539     break;
 540   }
 541   return PERL_constant_NOTFOUND;
 542 }
 543
 544 static void
 545 restore_sigmask(pTHX_ SV *osset_sv)
 546 {
 547      /* Fortunately, restoring the signal mask can't fail, because
 548       * there's nothing we can do about it if it does -- we're not
 549       * supposed to return -1 from sigaction unless the disposition
 550       * was unaffected.
 551       */
 552      sigset_t *ossetp = (sigset_t *) SvPV_nolen( osset_sv );
 553      (void)sigprocmask(SIG_SETMASK, ossetp, (sigset_t *)0);
 554 }
 555
 556 MODULE = SigSet         PACKAGE = POSIX::SigSet         PREFIX = sig
 557
 558 POSIX::SigSet
 559 new(packname = "POSIX::SigSet", ...)
 560     char *              packname
 561     CODE:
 562         {
 563             int i;
 564             New(0, RETVAL, 1, sigset_t);
 565             sigemptyset(RETVAL);
 566             for (i = 1; i < items; i++)
 567                 sigaddset(RETVAL, SvIV(ST(i)));
 568         }
 569     OUTPUT:
 570         RETVAL
 571
 572 void
 573 DESTROY(sigset)
 574         POSIX::SigSet   sigset
 575     CODE:
 576         Safefree(sigset);
 577
 578 SysRet
 579 sigaddset(sigset, sig)
 580         POSIX::SigSet   sigset
 581         int             sig
 582
 583 SysRet
 584 sigdelset(sigset, sig)
 585         POSIX::SigSet   sigset
 586         int             sig
 587
 588 SysRet
 589 sigemptyset(sigset)
 590         POSIX::SigSet   sigset
 591
 592 SysRet
 593 sigfillset(sigset)
 594         POSIX::SigSet   sigset
 595
 596 int
 597 sigismember(sigset, sig)
 598         POSIX::SigSet   sigset
 599         int             sig
 600
 601
 602 MODULE = Termios        PACKAGE = POSIX::Termios        PREFIX = cf
 603
 604 POSIX::Termios
 605 new(packname = "POSIX::Termios", ...)
 606     char *              packname
 607     CODE:
 608         {
 609 #ifdef I_TERMIOS
 610             New(0, RETVAL, 1, struct termios);
 611 #else
 612             not_here("termios");
 613         RETVAL = 0;
 614 #endif
 615         }
 616     OUTPUT:
 617         RETVAL
 618
 619 void
 620 DESTROY(termios_ref)
 621         POSIX::Termios  termios_ref
 622     CODE:
 623 #ifdef I_TERMIOS
 624         Safefree(termios_ref);
 625 #else
 626             not_here("termios");
 627 #endif
 628
 629 SysRet
 630 getattr(termios_ref, fd = 0)
 631         POSIX::Termios  termios_ref
 632         int             fd
 633     CODE:
 634         RETVAL = tcgetattr(fd, termios_ref);
 635     OUTPUT:
 636         RETVAL
 637
 638 SysRet
 639 setattr(termios_ref, fd = 0, optional_actions = 0)
 640         POSIX::Termios  termios_ref
 641         int             fd
 642         int             optional_actions
 643     CODE:
 644         RETVAL = tcsetattr(fd, optional_actions, termios_ref);
 645     OUTPUT:
 646         RETVAL
 647
 648 speed_t
 649 cfgetispeed(termios_ref)
 650         POSIX::Termios  termios_ref
 651
 652 speed_t
 653 cfgetospeed(termios_ref)
 654         POSIX::Termios  termios_ref
 655
 656 tcflag_t
 657 getiflag(termios_ref)
 658         POSIX::Termios  termios_ref
 659     CODE:
 660 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 661         RETVAL = termios_ref->c_iflag;
 662 #else
 663      not_here("getiflag");
 664      RETVAL = 0;
 665 #endif
 666     OUTPUT:
 667         RETVAL
 668
 669 tcflag_t
 670 getoflag(termios_ref)
 671         POSIX::Termios  termios_ref
 672     CODE:
 673 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 674         RETVAL = termios_ref->c_oflag;
 675 #else
 676      not_here("getoflag");
 677      RETVAL = 0;
 678 #endif
 679     OUTPUT:
 680         RETVAL
 681
 682 tcflag_t
 683 getcflag(termios_ref)
 684         POSIX::Termios  termios_ref
 685     CODE:
 686 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 687         RETVAL = termios_ref->c_cflag;
 688 #else
 689      not_here("getcflag");
 690      RETVAL = 0;
 691 #endif
 692     OUTPUT:
 693         RETVAL
 694
 695 tcflag_t
 696 getlflag(termios_ref)
 697         POSIX::Termios  termios_ref
 698     CODE:
 699 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 700         RETVAL = termios_ref->c_lflag;
 701 #else
 702      not_here("getlflag");
 703      RETVAL = 0;
 704 #endif
 705     OUTPUT:
 706         RETVAL
 707
 708 cc_t
 709 getcc(termios_ref, ccix)
 710         POSIX::Termios  termios_ref
 711         int             ccix
 712     CODE:
 713 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 714         if (ccix >= NCCS)
 715             croak("Bad getcc subscript");
 716         RETVAL = termios_ref->c_cc[ccix];
 717 #else
 718      not_here("getcc");
 719      RETVAL = 0;
 720 #endif
 721     OUTPUT:
 722         RETVAL
 723
 724 SysRet
 725 cfsetispeed(termios_ref, speed)
 726         POSIX::Termios  termios_ref
 727         speed_t         speed
 728
 729 SysRet
 730 cfsetospeed(termios_ref, speed)
 731         POSIX::Termios  termios_ref
 732         speed_t         speed
 733
 734 void
 735 setiflag(termios_ref, iflag)
 736         POSIX::Termios  termios_ref
 737         tcflag_t        iflag
 738     CODE:
 739 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 740         termios_ref->c_iflag = iflag;
 741 #else
 742             not_here("setiflag");
 743 #endif
 744
 745 void
 746 setoflag(termios_ref, oflag)
 747         POSIX::Termios  termios_ref
 748         tcflag_t        oflag
 749     CODE:
 750 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 751         termios_ref->c_oflag = oflag;
 752 #else
 753             not_here("setoflag");
 754 #endif
 755
 756 void
 757 setcflag(termios_ref, cflag)
 758         POSIX::Termios  termios_ref
 759         tcflag_t        cflag
 760     CODE:
 761 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 762         termios_ref->c_cflag = cflag;
 763 #else
 764             not_here("setcflag");
 765 #endif
 766
 767 void
 768 setlflag(termios_ref, lflag)
 769         POSIX::Termios  termios_ref
 770         tcflag_t        lflag
 771     CODE:
 772 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 773         termios_ref->c_lflag = lflag;
 774 #else
 775             not_here("setlflag");
 776 #endif
 777
 778 void
 779 setcc(termios_ref, ccix, cc)
 780         POSIX::Termios  termios_ref
 781         int             ccix
 782         cc_t            cc
 783     CODE:
 784 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
 785         if (ccix >= NCCS)
 786             croak("Bad setcc subscript");
 787         termios_ref->c_cc[ccix] = cc;
 788 #else
 789             not_here("setcc");
 790 #endif
 791
 792
 793 MODULE = POSIX          PACKAGE = POSIX
 794
 795 INCLUDE: const-xs.inc
 796
 797 void
 798 int_macro_int(sv, iv)
 799     PREINIT:
 800         dXSTARG;
 801         STRLEN          len;
 802         int             type;
 803     INPUT:
 804         SV *            sv;
 805         const char *    s = SvPV(sv, len);
 806         IV              iv;
 807     PPCODE:
 808         /* Change this to int_macro_int(s, len, &iv, &nv);
 809            if you need to return both NVs and IVs */
 810         type = int_macro_int(s, len, &iv);
 811       /* Return 1 or 2 items. First is error message, or undef if no error.
 812            Second, if present, is found value */
 813         switch (type) {
 814         case PERL_constant_NOTFOUND:
 815           sv = sv_2mortal(newSVpvf("%s is not a valid POSIX macro", s));
 816           EXTEND(SP, 1);
 817           PUSHs(&PL_sv_undef);
 818           PUSHs(sv);
 819           break;
 820         case PERL_constant_NOTDEF:
 821           sv = sv_2mortal(newSVpvf(
 822             "Your vendor has not defined POSIX macro %s, used", s));
 823           EXTEND(SP, 1);
 824           PUSHs(&PL_sv_undef);
 825           PUSHs(sv);
 826           break;
 827         case PERL_constant_ISIV:
 828           PUSHi(iv);
 829           break;
 830         default:
 831           sv = sv_2mortal(newSVpvf(
 832             "Unexpected return type %d while processing POSIX macro %s, used",
 833                type, s));
 834           EXTEND(SP, 1);
 835           PUSHs(&PL_sv_undef);
 836           PUSHs(sv);
 837         }
 838
 839 int
 840 isalnum(charstring)
 841         unsigned char * charstring
 842     CODE:
 843         unsigned char *s = charstring;
 844         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 845         for (RETVAL = 1; RETVAL && s < e; s++)
 846             if (!isalnum(*s))
 847                 RETVAL = 0;
 848     OUTPUT:
 849         RETVAL
 850
 851 int
 852 isalpha(charstring)
 853         unsigned char * charstring
 854     CODE:
 855         unsigned char *s = charstring;
 856         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 857         for (RETVAL = 1; RETVAL && s < e; s++)
 858             if (!isalpha(*s))
 859                 RETVAL = 0;
 860     OUTPUT:
 861         RETVAL
 862
 863 int
 864 iscntrl(charstring)
 865         unsigned char * charstring
 866     CODE:
 867         unsigned char *s = charstring;
 868         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 869         for (RETVAL = 1; RETVAL && s < e; s++)
 870             if (!iscntrl(*s))
 871                 RETVAL = 0;
 872     OUTPUT:
 873         RETVAL
 874
 875 int
 876 isdigit(charstring)
 877         unsigned char * charstring
 878     CODE:
 879         unsigned char *s = charstring;
 880         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 881         for (RETVAL = 1; RETVAL && s < e; s++)
 882             if (!isdigit(*s))
 883                 RETVAL = 0;
 884     OUTPUT:
 885         RETVAL
 886
 887 int
 888 isgraph(charstring)
 889         unsigned char * charstring
 890     CODE:
 891         unsigned char *s = charstring;
 892         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 893         for (RETVAL = 1; RETVAL && s < e; s++)
 894             if (!isgraph(*s))
 895                 RETVAL = 0;
 896     OUTPUT:
 897         RETVAL
 898
 899 int
 900 islower(charstring)
 901         unsigned char * charstring
 902     CODE:
 903         unsigned char *s = charstring;
 904         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 905         for (RETVAL = 1; RETVAL && s < e; s++)
 906             if (!islower(*s))
 907                 RETVAL = 0;
 908     OUTPUT:
 909         RETVAL
 910
 911 int
 912 isprint(charstring)
 913         unsigned char * charstring
 914     CODE:
 915         unsigned char *s = charstring;
 916         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 917         for (RETVAL = 1; RETVAL && s < e; s++)
 918             if (!isprint(*s))
 919                 RETVAL = 0;
 920     OUTPUT:
 921         RETVAL
 922
 923 int
 924 ispunct(charstring)
 925         unsigned char * charstring
 926     CODE:
 927         unsigned char *s = charstring;
 928         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 929         for (RETVAL = 1; RETVAL && s < e; s++)
 930             if (!ispunct(*s))
 931                 RETVAL = 0;
 932     OUTPUT:
 933         RETVAL
 934
 935 int
 936 isspace(charstring)
 937         unsigned char * charstring
 938     CODE:
 939         unsigned char *s = charstring;
 940         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 941         for (RETVAL = 1; RETVAL && s < e; s++)
 942             if (!isspace(*s))
 943                 RETVAL = 0;
 944     OUTPUT:
 945         RETVAL
 946
 947 int
 948 isupper(charstring)
 949         unsigned char * charstring
 950     CODE:
 951         unsigned char *s = charstring;
 952         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 953         for (RETVAL = 1; RETVAL && s < e; s++)
 954             if (!isupper(*s))
 955                 RETVAL = 0;
 956     OUTPUT:
 957         RETVAL
 958
 959 int
 960 isxdigit(charstring)
 961         unsigned char * charstring
 962     CODE:
 963         unsigned char *s = charstring;
 964         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
 965         for (RETVAL = 1; RETVAL && s < e; s++)
 966             if (!isxdigit(*s))
 967                 RETVAL = 0;
 968     OUTPUT:
 969         RETVAL
 970
 971 SysRet
 972 open(filename, flags = O_RDONLY, mode = 0666)
 973         char *          filename
 974         int             flags
 975         Mode_t          mode
 976     CODE:
 977         if (flags & (O_APPEND|O_CREAT|O_TRUNC|O_RDWR|O_WRONLY|O_EXCL))
 978             TAINT_PROPER("open");
 979         RETVAL = open(filename, flags, mode);
 980     OUTPUT:
 981         RETVAL
 982
 983
 984 HV *
 985 localeconv()
 986     CODE:
 987 #ifdef HAS_LOCALECONV
 988         struct lconv *lcbuf;
 989         RETVAL = newHV();
 990         if ((lcbuf = localeconv())) {
 991             /* the strings */
 992             if (lcbuf->decimal_point && *lcbuf->decimal_point)
 993                 hv_store(RETVAL, "decimal_point", 13,
 994                     newSVpv(lcbuf->decimal_point, 0), 0);
 995             if (lcbuf->thousands_sep && *lcbuf->thousands_sep)
 996                 hv_store(RETVAL, "thousands_sep", 13,
 997                     newSVpv(lcbuf->thousands_sep, 0), 0);
 998 #ifndef NO_LOCALECONV_GROUPING
 999             if (lcbuf->grouping && *lcbuf->grouping)
1000                 hv_store(RETVAL, "grouping", 8,
1001                     newSVpv(lcbuf->grouping, 0), 0);
1002 #endif
1003             if (lcbuf->int_curr_symbol && *lcbuf->int_curr_symbol)
1004                 hv_store(RETVAL, "int_curr_symbol", 15,
1005                     newSVpv(lcbuf->int_curr_symbol, 0), 0);
1006             if (lcbuf->currency_symbol && *lcbuf->currency_symbol)
1007                 hv_store(RETVAL, "currency_symbol", 15,
1008                     newSVpv(lcbuf->currency_symbol, 0), 0);
1009             if (lcbuf->mon_decimal_point && *lcbuf->mon_decimal_point)
1010                 hv_store(RETVAL, "mon_decimal_point", 17,
1011                     newSVpv(lcbuf->mon_decimal_point, 0), 0);
1012 #ifndef NO_LOCALECONV_MON_THOUSANDS_SEP
1013             if (lcbuf->mon_thousands_sep && *lcbuf->mon_thousands_sep)
1014                 hv_store(RETVAL, "mon_thousands_sep", 17,
1015                     newSVpv(lcbuf->mon_thousands_sep, 0), 0);
1016 #endif
1017 #ifndef NO_LOCALECONV_MON_GROUPING
1018             if (lcbuf->mon_grouping && *lcbuf->mon_grouping)
1019                 hv_store(RETVAL, "mon_grouping", 12,
1020                     newSVpv(lcbuf->mon_grouping, 0), 0);
1021 #endif
1022             if (lcbuf->positive_sign && *lcbuf->positive_sign)
1023                 hv_store(RETVAL, "positive_sign", 13,
1024                     newSVpv(lcbuf->positive_sign, 0), 0);
1025             if (lcbuf->negative_sign && *lcbuf->negative_sign)
1026                 hv_store(RETVAL, "negative_sign", 13,
1027                     newSVpv(lcbuf->negative_sign, 0), 0);
1028             /* the integers */
1029             if (lcbuf->int_frac_digits != CHAR_MAX)
1030                 hv_store(RETVAL, "int_frac_digits", 15,
1031                     newSViv(lcbuf->int_frac_digits), 0);
1032             if (lcbuf->frac_digits != CHAR_MAX)
1033                 hv_store(RETVAL, "frac_digits", 11,
1034                     newSViv(lcbuf->frac_digits), 0);
1035             if (lcbuf->p_cs_precedes != CHAR_MAX)
1036                 hv_store(RETVAL, "p_cs_precedes", 13,
1037                     newSViv(lcbuf->p_cs_precedes), 0);
1038             if (lcbuf->p_sep_by_space != CHAR_MAX)
1039                 hv_store(RETVAL, "p_sep_by_space", 14,
1040                     newSViv(lcbuf->p_sep_by_space), 0);
1041             if (lcbuf->n_cs_precedes != CHAR_MAX)
1042                 hv_store(RETVAL, "n_cs_precedes", 13,
1043                     newSViv(lcbuf->n_cs_precedes), 0);
1044             if (lcbuf->n_sep_by_space != CHAR_MAX)
1045                 hv_store(RETVAL, "n_sep_by_space", 14,
1046                     newSViv(lcbuf->n_sep_by_space), 0);
1047             if (lcbuf->p_sign_posn != CHAR_MAX)
1048                 hv_store(RETVAL, "p_sign_posn", 11,
1049                     newSViv(lcbuf->p_sign_posn), 0);
1050             if (lcbuf->n_sign_posn != CHAR_MAX)
1051                 hv_store(RETVAL, "n_sign_posn", 11,
1052                     newSViv(lcbuf->n_sign_posn), 0);
1053         }
1054 #else
1055         localeconv(); /* A stub to call not_here(). */
1056 #endif
1057     OUTPUT:
1058         RETVAL
1059
1060 char *
1061 setlocale(category, locale = 0)
1062         int             category
1063         char *          locale
1064     CODE:
1065         RETVAL = setlocale(category, locale);
1066         if (RETVAL) {
1067 #ifdef USE_LOCALE_CTYPE
1068             if (category == LC_CTYPE
1069 #ifdef LC_ALL
1070                 || category == LC_ALL
1071 #endif
1072                 )
1073             {
1074                 char *newctype;
1075 #ifdef LC_ALL
1076                 if (category == LC_ALL)
1077                     newctype = setlocale(LC_CTYPE, NULL);
1078                 else
1079 #endif
1080                     newctype = RETVAL;
1081                 new_ctype(newctype);
1082             }
1083 #endif /* USE_LOCALE_CTYPE */
1084 #ifdef USE_LOCALE_COLLATE
1085             if (category == LC_COLLATE
1086 #ifdef LC_ALL
1087                 || category == LC_ALL
1088 #endif
1089                 )
1090             {
1091                 char *newcoll;
1092 #ifdef LC_ALL
1093                 if (category == LC_ALL)
1094                     newcoll = setlocale(LC_COLLATE, NULL);
1095                 else
1096 #endif
1097                     newcoll = RETVAL;
1098                 new_collate(newcoll);
1099             }
1100 #endif /* USE_LOCALE_COLLATE */
1101 #ifdef USE_LOCALE_NUMERIC
1102             if (category == LC_NUMERIC
1103 #ifdef LC_ALL
1104                 || category == LC_ALL
1105 #endif
1106                 )
1107             {
1108                 char *newnum;
1109 #ifdef LC_ALL
1110                 if (category == LC_ALL)
1111                     newnum = setlocale(LC_NUMERIC, NULL);
1112                 else
1113 #endif
1114                     newnum = RETVAL;
1115                 new_numeric(newnum);
1116             }
1117 #endif /* USE_LOCALE_NUMERIC */
1118         }
1119     OUTPUT:
1120         RETVAL
1121
1122
1123 NV
1124 acos(x)
1125         NV              x
1126
1127 NV
1128 asin(x)
1129         NV              x
1130
1131 NV
1132 atan(x)
1133         NV              x
1134
1135 NV
1136 ceil(x)
1137         NV              x
1138
1139 NV
1140 cosh(x)
1141         NV              x
1142
1143 NV
1144 floor(x)
1145         NV              x
1146
1147 NV
1148 fmod(x,y)
1149         NV              x
1150         NV              y
1151
1152 void
1153 frexp(x)
1154         NV              x
1155     PPCODE:
1156         int expvar;
1157         /* (We already know stack is long enough.) */
1158         PUSHs(sv_2mortal(newSVnv(frexp(x,&expvar))));
1159         PUSHs(sv_2mortal(newSViv(expvar)));
1160
1161 NV
1162 ldexp(x,exp)
1163         NV              x
1164         int             exp
1165
1166 NV
1167 log10(x)
1168         NV              x
1169
1170 void
1171 modf(x)
1172         NV              x
1173     PPCODE:
1174         NV intvar;
1175         /* (We already know stack is long enough.) */
1176         PUSHs(sv_2mortal(newSVnv(Perl_modf(x,&intvar))));
1177         PUSHs(sv_2mortal(newSVnv(intvar)));
1178
1179 NV
1180 sinh(x)
1181         NV              x
1182
1183 NV
1184 tan(x)
1185         NV              x
1186
1187 NV
1188 tanh(x)
1189         NV              x
1190
1191 SysRet
1192 sigaction(sig, optaction, oldaction = 0)
1193         int                     sig
1194         SV *                    optaction
1195         POSIX::SigAction        oldaction
1196     CODE:
1197 #if defined(WIN32) || defined(NETWARE)
1198         RETVAL = not_here("sigaction");
1199 #else
1200 # This code is really grody because we're trying to make the signal
1201 # interface look beautiful, which is hard.
1202
1203         {
1204             POSIX__SigAction action;
1205             GV *siggv = gv_fetchpv("SIG", TRUE, SVt_PVHV);
1206             struct sigaction act;
1207             struct sigaction oact;
1208             sigset_t sset;
1209             SV *osset_sv;
1210             sigset_t osset;
1211             POSIX__SigSet sigset;
1212             SV** svp;
1213             SV** sigsvp = hv_fetch(GvHVn(siggv),
1214                                  PL_sig_name[sig],
1215                                  strlen(PL_sig_name[sig]),
1216                                  TRUE);
1217
1218             /* Check optaction and set action */
1219             if(SvTRUE(optaction)) {
1220                 if(sv_isa(optaction, "POSIX::SigAction"))
1221                         action = (HV*)SvRV(optaction);
1222                 else
1223                         croak("action is not of type POSIX::SigAction");
1224             }
1225             else {
1226                 action=0;
1227             }
1228
1229             /* sigaction() is supposed to look atomic. In particular, any
1230              * signal handler invoked during a sigaction() call should
1231              * see either the old or the new disposition, and not something
1232              * in between. We use sigprocmask() to make it so.
1233              */
1234             sigfillset(&sset);
1235             RETVAL=sigprocmask(SIG_BLOCK, &sset, &osset);
1236             if(RETVAL == -1)
1237                XSRETURN_UNDEF;
1238             ENTER;
1239             /* Restore signal mask no matter how we exit this block. */
1240             osset_sv = newSVpv((char *)(&osset), sizeof(sigset_t));
1241             SAVEFREESV( osset_sv );
1242             SAVEDESTRUCTOR_X(restore_sigmask, osset_sv);
1243
1244             RETVAL=-1; /* In case both oldaction and action are 0. */
1245
1246             /* Remember old disposition if desired. */
1247             if (oldaction) {
1248                 svp = hv_fetch(oldaction, "HANDLER", 7, TRUE);
1249                 if(!svp)
1250                     croak("Can't supply an oldaction without a HANDLER");
1251                 if(SvTRUE(*sigsvp)) { /* TBD: what if "0"? */
1252                         sv_setsv(*svp, *sigsvp);
1253                 }
1254                 else {
1255                         sv_setpv(*svp, "DEFAULT");
1256                 }
1257                 RETVAL = sigaction(sig, (struct sigaction *)0, & oact);
1258                 if(RETVAL == -1)
1259                    XSRETURN_UNDEF;
1260                 /* Get back the mask. */
1261                 svp = hv_fetch(oldaction, "MASK", 4, TRUE);
1262                 if (sv_isa(*svp, "POSIX::SigSet")) {
1263                     IV tmp = SvIV((SV*)SvRV(*svp));
1264                     sigset = INT2PTR(sigset_t*, tmp);
1265                 }
1266                 else {
1267                     New(0, sigset, 1, sigset_t);
1268                     sv_setptrobj(*svp, sigset, "POSIX::SigSet");
1269                 }
1270                 *sigset = oact.sa_mask;
1271
1272                 /* Get back the flags. */
1273                 svp = hv_fetch(oldaction, "FLAGS", 5, TRUE);
1274                 sv_setiv(*svp, oact.sa_flags);
1275             }
1276
1277             if (action) {
1278                 /* Vector new handler through %SIG.  (We always use sighandler
1279                    for the C signal handler, which reads %SIG to dispatch.) */
1280                 svp = hv_fetch(action, "HANDLER", 7, FALSE);
1281                 if (!svp)
1282                     croak("Can't supply an action without a HANDLER");
1283                 sv_setsv(*sigsvp, *svp);
1284                 mg_set(*sigsvp);        /* handles DEFAULT and IGNORE */
1285                 if(SvPOK(*svp)) {
1286                         char *s=SvPVX(*svp);
1287                         if(strEQ(s,"IGNORE")) {
1288                                 act.sa_handler = SIG_IGN;
1289                         }
1290                         else if(strEQ(s,"DEFAULT")) {
1291                                 act.sa_handler = SIG_DFL;
1292                         }
1293                         else {
1294                                 act.sa_handler = PL_sighandlerp;
1295                         }
1296                 }
1297                 else {
1298                         act.sa_handler = PL_sighandlerp;
1299                 }
1300
1301                 /* Set up any desired mask. */
1302                 svp = hv_fetch(action, "MASK", 4, FALSE);
1303                 if (svp && sv_isa(*svp, "POSIX::SigSet")) {
1304                     IV tmp = SvIV((SV*)SvRV(*svp));
1305                     sigset = INT2PTR(sigset_t*, tmp);
1306                     act.sa_mask = *sigset;
1307                 }
1308                 else
1309                     sigemptyset(& act.sa_mask);
1310
1311                 /* Set up any desired flags. */
1312                 svp = hv_fetch(action, "FLAGS", 5, FALSE);
1313                 act.sa_flags = svp ? SvIV(*svp) : 0;
1314
1315                 /* Don't worry about cleaning up *sigsvp if this fails,
1316                  * because that means we tried to disposition a
1317                  * nonblockable signal, in which case *sigsvp is
1318                  * essentially meaningless anyway.
1319                  */
1320                 RETVAL = sigaction(sig, & act, (struct sigaction *)0);
1321                if(RETVAL == -1)
1322                    XSRETURN_UNDEF;
1323             }
1324
1325             LEAVE;
1326         }
1327 #endif
1328     OUTPUT:
1329         RETVAL
1330
1331 SysRet
1332 sigpending(sigset)
1333         POSIX::SigSet           sigset
1334
1335 SysRet
1336 sigprocmask(how, sigset, oldsigset = 0)
1337         int                     how
1338         POSIX::SigSet           sigset
1339         POSIX::SigSet           oldsigset = NO_INIT
1340 INIT:
1341         if ( items < 3 ) {
1342             oldsigset = 0;
1343         }
1344         else if (sv_derived_from(ST(2), "POSIX::SigSet")) {
1345             IV tmp = SvIV((SV*)SvRV(ST(2)));
1346             oldsigset = INT2PTR(POSIX__SigSet,tmp);
1347         }
1348         else {
1349             New(0, oldsigset, 1, sigset_t);
1350             sigemptyset(oldsigset);
1351             sv_setref_pv(ST(2), "POSIX::SigSet", (void*)oldsigset);
1352         }
1353
1354 SysRet
1355 sigsuspend(signal_mask)
1356         POSIX::SigSet           signal_mask
1357
1358 void
1359 _exit(status)
1360         int             status
1361
1362 SysRet
1363 close(fd)
1364         int             fd
1365
1366 SysRet
1367 dup(fd)
1368         int             fd
1369
1370 SysRet
1371 dup2(fd1, fd2)
1372         int             fd1
1373         int             fd2
1374
1375 SysRetLong
1376 lseek(fd, offset, whence)
1377         int             fd
1378         Off_t           offset
1379         int             whence
1380
1381 SysRet
1382 nice(incr)
1383         int             incr
1384
1385 void
1386 pipe()
1387     PPCODE:
1388         int fds[2];
1389         if (pipe(fds) != -1) {
1390             EXTEND(SP,2);
1391             PUSHs(sv_2mortal(newSViv(fds[0])));
1392             PUSHs(sv_2mortal(newSViv(fds[1])));
1393         }
1394
1395 SysRet
1396 read(fd, buffer, nbytes)
1397     PREINIT:
1398         SV *sv_buffer = SvROK(ST(1)) ? SvRV(ST(1)) : ST(1);
1399     INPUT:
1400         int             fd
1401         size_t          nbytes
1402         char *          buffer = sv_grow( sv_buffer, nbytes+1 );
1403     CLEANUP:
1404         if (RETVAL >= 0) {
1405             SvCUR(sv_buffer) = RETVAL;
1406             SvPOK_only(sv_buffer);
1407             *SvEND(sv_buffer) = '\0';
1408             SvTAINTED_on(sv_buffer);
1409         }
1410
1411 SysRet
1412 setpgid(pid, pgid)
1413         pid_t           pid
1414         pid_t           pgid
1415
1416 pid_t
1417 setsid()
1418
1419 pid_t
1420 tcgetpgrp(fd)
1421         int             fd
1422
1423 SysRet
1424 tcsetpgrp(fd, pgrp_id)
1425         int             fd
1426         pid_t           pgrp_id
1427
1428 void
1429 uname()
1430     PPCODE:
1431 #ifdef HAS_UNAME
1432         struct utsname buf;
1433         if (uname(&buf) >= 0) {
1434             EXTEND(SP, 5);
1435             PUSHs(sv_2mortal(newSVpv(buf.sysname, 0)));
1436             PUSHs(sv_2mortal(newSVpv(buf.nodename, 0)));
1437             PUSHs(sv_2mortal(newSVpv(buf.release, 0)));
1438             PUSHs(sv_2mortal(newSVpv(buf.version, 0)));
1439             PUSHs(sv_2mortal(newSVpv(buf.machine, 0)));
1440         }
1441 #else
1442         uname((char *) 0); /* A stub to call not_here(). */
1443 #endif
1444
1445 SysRet
1446 write(fd, buffer, nbytes)
1447         int             fd
1448         char *          buffer
1449         size_t          nbytes
1450
1451 SV *
1452 tmpnam()
1453     PREINIT:
1454         STRLEN i;
1455         int len;
1456     CODE:
1457         RETVAL = newSVpvn("", 0);
1458         SvGROW(RETVAL, L_tmpnam);
1459         len = strlen(tmpnam(SvPV(RETVAL, i)));
1460         SvCUR_set(RETVAL, len);
1461     OUTPUT:
1462         RETVAL
1463
1464 void
1465 abort()
1466
1467 int
1468 mblen(s, n)
1469         char *          s
1470         size_t          n
1471
1472 size_t
1473 mbstowcs(s, pwcs, n)
1474         wchar_t *       s
1475         char *          pwcs
1476         size_t          n
1477
1478 int
1479 mbtowc(pwc, s, n)
1480         wchar_t *       pwc
1481         char *          s
1482         size_t          n
1483
1484 int
1485 wcstombs(s, pwcs, n)
1486         char *          s
1487         wchar_t *       pwcs
1488         size_t          n
1489
1490 int
1491 wctomb(s, wchar)
1492         char *          s
1493         wchar_t         wchar
1494
1495 int
1496 strcoll(s1, s2)
1497         char *          s1
1498         char *          s2
1499
1500 void
1501 strtod(str)
1502         char *          str
1503     PREINIT:
1504         double num;
1505         char *unparsed;
1506     PPCODE:
1507         SET_NUMERIC_LOCAL();
1508         num = strtod(str, &unparsed);
1509         PUSHs(sv_2mortal(newSVnv(num)));
1510         if (GIMME == G_ARRAY) {
1511             EXTEND(SP, 1);
1512             if (unparsed)
1513                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1514             else
1515                 PUSHs(&PL_sv_undef);
1516         }
1517
1518 void
1519 strtol(str, base = 0)
1520         char *          str
1521         int             base
1522     PREINIT:
1523         long num;
1524         char *unparsed;
1525     PPCODE:
1526         num = strtol(str, &unparsed, base);
1527 #if IVSIZE <= LONGSIZE
1528         if (num < IV_MIN || num > IV_MAX)
1529             PUSHs(sv_2mortal(newSVnv((double)num)));
1530         else
1531 #endif
1532             PUSHs(sv_2mortal(newSViv((IV)num)));
1533         if (GIMME == G_ARRAY) {
1534             EXTEND(SP, 1);
1535             if (unparsed)
1536                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1537             else
1538                 PUSHs(&PL_sv_undef);
1539         }
1540
1541 void
1542 strtoul(str, base = 0)
1543         char *          str
1544         int             base
1545     PREINIT:
1546         unsigned long num;
1547         char *unparsed;
1548     PPCODE:
1549         num = strtoul(str, &unparsed, base);
1550         if (num <= IV_MAX)
1551             PUSHs(sv_2mortal(newSViv((IV)num)));
1552         else
1553             PUSHs(sv_2mortal(newSVnv((double)num)));
1554         if (GIMME == G_ARRAY) {
1555             EXTEND(SP, 1);
1556             if (unparsed)
1557                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1558             else
1559                 PUSHs(&PL_sv_undef);
1560         }
1561
1562 void
1563 strxfrm(src)
1564         SV *            src
1565     CODE:
1566         {
1567           STRLEN srclen;
1568           STRLEN dstlen;
1569           char *p = SvPV(src,srclen);
1570           srclen++;
1571           ST(0) = sv_2mortal(NEWSV(800,srclen));
1572           dstlen = strxfrm(SvPVX(ST(0)), p, (size_t)srclen);
1573           if (dstlen > srclen) {
1574               dstlen++;
1575               SvGROW(ST(0), dstlen);
1576               strxfrm(SvPVX(ST(0)), p, (size_t)dstlen);
1577               dstlen--;
1578           }
1579           SvCUR(ST(0)) = dstlen;
1580             SvPOK_only(ST(0));
1581         }
1582
1583 SysRet
1584 mkfifo(filename, mode)
1585         char *          filename
1586         Mode_t          mode
1587     CODE:
1588         TAINT_PROPER("mkfifo");
1589         RETVAL = mkfifo(filename, mode);
1590     OUTPUT:
1591         RETVAL
1592
1593 SysRet
1594 tcdrain(fd)
1595         int             fd
1596
1597
1598 SysRet
1599 tcflow(fd, action)
1600         int             fd
1601         int             action
1602
1603
1604 SysRet
1605 tcflush(fd, queue_selector)
1606         int             fd
1607         int             queue_selector
1608
1609 SysRet
1610 tcsendbreak(fd, duration)
1611         int             fd
1612         int             duration
1613
1614 char *
1615 asctime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
1616         int             sec
1617         int             min
1618         int             hour
1619         int             mday
1620         int             mon
1621         int             year
1622         int             wday
1623         int             yday
1624         int             isdst
1625     CODE:
1626         {
1627             struct tm mytm;
1628             init_tm(&mytm);     /* XXX workaround - see init_tm() above */
1629             mytm.tm_sec = sec;
1630             mytm.tm_min = min;
1631             mytm.tm_hour = hour;
1632             mytm.tm_mday = mday;
1633             mytm.tm_mon = mon;
1634             mytm.tm_year = year;
1635             mytm.tm_wday = wday;
1636             mytm.tm_yday = yday;
1637             mytm.tm_isdst = isdst;
1638             RETVAL = asctime(&mytm);
1639         }
1640     OUTPUT:
1641         RETVAL
1642
1643 long
1644 clock()
1645
1646 char *
1647 ctime(time)
1648         Time_t          &time
1649
1650 void
1651 times()
1652         PPCODE:
1653         struct tms tms;
1654         clock_t realtime;
1655         realtime = times( &tms );
1656         EXTEND(SP,5);
1657         PUSHs( sv_2mortal( newSViv( (IV) realtime ) ) );
1658         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_utime ) ) );
1659         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_stime ) ) );
1660         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cutime ) ) );
1661         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cstime ) ) );
1662
1663 double
1664 difftime(time1, time2)
1665         Time_t          time1
1666         Time_t          time2
1667
1668 SysRetLong
1669 mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
1670         int             sec
1671         int             min
1672         int             hour
1673         int             mday
1674         int             mon
1675         int             year
1676         int             wday
1677         int             yday
1678         int             isdst
1679     CODE:
1680         {
1681             struct tm mytm;
1682             init_tm(&mytm);     /* XXX workaround - see init_tm() above */
1683             mytm.tm_sec = sec;
1684             mytm.tm_min = min;
1685             mytm.tm_hour = hour;
1686             mytm.tm_mday = mday;
1687             mytm.tm_mon = mon;
1688             mytm.tm_year = year;
1689             mytm.tm_wday = wday;
1690             mytm.tm_yday = yday;
1691             mytm.tm_isdst = isdst;
1692             RETVAL = mktime(&mytm);
1693         }
1694     OUTPUT:
1695         RETVAL
1696
1697 #XXX: if $xsubpp::WantOptimize is always the default
1698 #     sv_setpv(TARG, ...) could be used rather than
1699 #     ST(0) = sv_2mortal(newSVpv(...))
1700 void
1701 strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
1702         char *          fmt
1703         int             sec
1704         int             min
1705         int             hour
1706         int             mday
1707         int             mon
1708         int             year
1709         int             wday
1710         int             yday
1711         int             isdst
1712     CODE:
1713         {
1714             char *buf = my_strftime(fmt, sec, min, hour, mday, mon, year, wday, yday, isdst);
1715             if (buf) {
1716                 ST(0) = sv_2mortal(newSVpv(buf, 0));
1717                 Safefree(buf);
1718             }
1719         }
1720
1721 void
1722 tzset()
1723
1724 void
1725 tzname()
1726     PPCODE:
1727         EXTEND(SP,2);
1728         PUSHs(sv_2mortal(newSVpvn(tzname[0],strlen(tzname[0]))));
1729         PUSHs(sv_2mortal(newSVpvn(tzname[1],strlen(tzname[1]))));
1730
1731 SysRet
1732 access(filename, mode)
1733         char *          filename
1734         Mode_t          mode
1735
1736 char *
1737 ctermid(s = 0)
1738         char *          s = 0;
1739
1740 char *
1741 cuserid(s = 0)
1742         char *          s = 0;
1743
1744 SysRetLong
1745 fpathconf(fd, name)
1746         int             fd
1747         int             name
1748
1749 SysRetLong
1750 pathconf(filename, name)
1751         char *          filename
1752         int             name
1753
1754 SysRet
1755 pause()
1756
1757 SysRet
1758 setgid(gid)
1759         Gid_t           gid
1760
1761 SysRet
1762 setuid(uid)
1763         Uid_t           uid
1764
1765 SysRetLong
1766 sysconf(name)
1767         int             name
1768
1769 char *
1770 ttyname(fd)
1771         int             fd
1772
1773 void
1774 getcwd()
1775     PPCODE:
1776       {
1777         dXSTARG;
1778         getcwd_sv(TARG);
1779         XSprePUSH; PUSHTARG;
1780       }
1781