ext/POSIX/POSIX.xs

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