[Summary view] [Print] [Text view]

   1  =head1 NAME
   2  
   3  POSIX - Perl interface to IEEE Std 1003.1
   4  
   5  =head1 SYNOPSIS
   6  
   7      use POSIX;
   8      use POSIX qw(setsid);
   9      use POSIX qw(:errno_h :fcntl_h);
  10  
  11      printf "EINTR is %d\n", EINTR;
  12  
  13      $sess_id = POSIX::setsid();
  14  
  15      $fd = POSIX::open($path, O_CREAT|O_EXCL|O_WRONLY, 0644);
  16      # note: that's a filedescriptor, *NOT* a filehandle
  17  
  18  =head1 DESCRIPTION
  19  
  20  The POSIX module permits you to access all (or nearly all) the standard
  21  POSIX 1003.1 identifiers.  Many of these identifiers have been given Perl-ish
  22  interfaces.
  23  
  24  I<Everything is exported by default> with the exception of any POSIX
  25  functions with the same name as a built-in Perl function, such as
  26  C<abs>, C<alarm>, C<rmdir>, C<write>, etc.., which will be exported
  27  only if you ask for them explicitly.  This is an unfortunate backwards
  28  compatibility feature.  You can stop the exporting by saying C<use
  29  POSIX ()> and then use the fully qualified names (ie. C<POSIX::SEEK_END>).
  30  
  31  This document gives a condensed list of the features available in the POSIX
  32  module.  Consult your operating system's manpages for general information on
  33  most features.  Consult L<perlfunc> for functions which are noted as being
  34  identical to Perl's builtin functions.
  35  
  36  The first section describes POSIX functions from the 1003.1 specification.
  37  The second section describes some classes for signal objects, TTY objects,
  38  and other miscellaneous objects.  The remaining sections list various
  39  constants and macros in an organization which roughly follows IEEE Std
  40  1003.1b-1993.
  41  
  42  =head1 NOTE
  43  
  44  The POSIX module is probably the most complex Perl module supplied with
  45  the standard distribution.  It incorporates autoloading, namespace games,
  46  and dynamic loading of code that's in Perl, C, or both.  It's a great
  47  source of wisdom.
  48  
  49  =head1 CAVEATS
  50  
  51  A few functions are not implemented because they are C specific.  If you
  52  attempt to call these, they will print a message telling you that they
  53  aren't implemented, and suggest using the Perl equivalent should one
  54  exist.  For example, trying to access the setjmp() call will elicit the
  55  message "setjmp() is C-specific: use eval {} instead".
  56  
  57  Furthermore, some evil vendors will claim 1003.1 compliance, but in fact
  58  are not so: they will not pass the PCTS (POSIX Compliance Test Suites).
  59  For example, one vendor may not define EDEADLK, or the semantics of the
  60  errno values set by open(2) might not be quite right.  Perl does not
  61  attempt to verify POSIX compliance.  That means you can currently
  62  successfully say "use POSIX",  and then later in your program you find
  63  that your vendor has been lax and there's no usable ICANON macro after
  64  all.  This could be construed to be a bug.
  65  
  66  =head1 FUNCTIONS
  67  
  68  =over 8
  69  
  70  =item _exit
  71  
  72  This is identical to the C function C<_exit()>.  It exits the program
  73  immediately which means among other things buffered I/O is B<not> flushed.
  74  
  75  Note that when using threads and in Linux this is B<not> a good way to
  76  exit a thread because in Linux processes and threads are kind of the
  77  same thing (Note: while this is the situation in early 2003 there are
  78  projects under way to have threads with more POSIXly semantics in Linux).
  79  If you want not to return from a thread, detach the thread.
  80  
  81  =item abort
  82  
  83  This is identical to the C function C<abort()>.  It terminates the
  84  process with a C<SIGABRT> signal unless caught by a signal handler or
  85  if the handler does not return normally (it e.g.  does a C<longjmp>).
  86  
  87  =item abs
  88  
  89  This is identical to Perl's builtin C<abs()> function, returning
  90  the absolute value of its numerical argument.
  91  
  92  =item access
  93  
  94  Determines the accessibility of a file.
  95  
  96      if( POSIX::access( "/", &POSIX::R_OK ) ){
  97          print "have read permission\n";
  98      }
  99  
 100  Returns C<undef> on failure.  Note: do not use C<access()> for
 101  security purposes.  Between the C<access()> call and the operation
 102  you are preparing for the permissions might change: a classic
 103  I<race condition>.
 104  
 105  =item acos
 106  
 107  This is identical to the C function C<acos()>, returning
 108  the arcus cosine of its numerical argument.  See also L<Math::Trig>.
 109  
 110  =item alarm
 111  
 112  This is identical to Perl's builtin C<alarm()> function,
 113  either for arming or disarming the C<SIGARLM> timer.
 114  
 115  =item asctime
 116  
 117  This is identical to the C function C<asctime()>.  It returns
 118  a string of the form
 119  
 120      "Fri Jun  2 18:22:13 2000\n\0"
 121  
 122  and it is called thusly
 123  
 124      $asctime = asctime($sec, $min, $hour, $mday, $mon, $year,
 125                 $wday, $yday, $isdst);
 126  
 127  The C<$mon> is zero-based: January equals C<0>.  The C<$year> is
 128  1900-based: 2001 equals C<101>.  C<$wday> and C<$yday> default to zero
 129  (and are usually ignored anyway), and C<$isdst> defaults to -1.
 130  
 131  =item asin
 132  
 133  This is identical to the C function C<asin()>, returning
 134  the arcus sine of its numerical argument.  See also L<Math::Trig>.
 135  
 136  =item assert
 137  
 138  Unimplemented, but you can use L<perlfunc/die> and the L<Carp> module
 139  to achieve similar things.
 140  
 141  =item atan
 142  
 143  This is identical to the C function C<atan()>, returning the
 144  arcus tangent of its numerical argument.  See also L<Math::Trig>.
 145  
 146  =item atan2
 147  
 148  This is identical to Perl's builtin C<atan2()> function, returning
 149  the arcus tangent defined by its two numerical arguments, the I<y>
 150  coordinate and the I<x> coordinate.  See also L<Math::Trig>.
 151  
 152  =item atexit
 153  
 154  atexit() is C-specific: use C<END {}> instead, see L<perlsub>.
 155  
 156  =item atof
 157  
 158  atof() is C-specific.  Perl converts strings to numbers transparently.
 159  If you need to force a scalar to a number, add a zero to it.
 160  
 161  =item atoi
 162  
 163  atoi() is C-specific.  Perl converts strings to numbers transparently.
 164  If you need to force a scalar to a number, add a zero to it.
 165  If you need to have just the integer part, see L<perlfunc/int>.
 166  
 167  =item atol
 168  
 169  atol() is C-specific.  Perl converts strings to numbers transparently.
 170  If you need to force a scalar to a number, add a zero to it.
 171  If you need to have just the integer part, see L<perlfunc/int>.
 172  
 173  =item bsearch
 174  
 175  bsearch() not supplied.  For doing binary search on wordlists,
 176  see L<Search::Dict>.
 177  
 178  =item calloc
 179  
 180  calloc() is C-specific.  Perl does memory management transparently.
 181  
 182  =item ceil
 183  
 184  This is identical to the C function C<ceil()>, returning the smallest
 185  integer value greater than or equal to the given numerical argument.
 186  
 187  =item chdir
 188  
 189  This is identical to Perl's builtin C<chdir()> function, allowing
 190  one to change the working (default) directory, see L<perlfunc/chdir>.
 191  
 192  =item chmod
 193  
 194  This is identical to Perl's builtin C<chmod()> function, allowing
 195  one to change file and directory permissions, see L<perlfunc/chmod>.
 196  
 197  =item chown
 198  
 199  This is identical to Perl's builtin C<chown()> function, allowing one
 200  to change file and directory owners and groups, see L<perlfunc/chown>.
 201  
 202  =item clearerr
 203  
 204  Use the method C<IO::Handle::clearerr()> instead, to reset the error
 205  state (if any) and EOF state (if any) of the given stream.
 206  
 207  =item clock
 208  
 209  This is identical to the C function C<clock()>, returning the
 210  amount of spent processor time in microseconds.
 211  
 212  =item close
 213  
 214  Close the file.  This uses file descriptors such as those obtained by calling
 215  C<POSIX::open>.
 216  
 217      $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
 218      POSIX::close( $fd );
 219  
 220  Returns C<undef> on failure.
 221  
 222  See also L<perlfunc/close>.
 223  
 224  =item closedir
 225  
 226  This is identical to Perl's builtin C<closedir()> function for closing
 227  a directory handle, see L<perlfunc/closedir>.
 228  
 229  =item cos
 230  
 231  This is identical to Perl's builtin C<cos()> function, for returning
 232  the cosine of its numerical argument, see L<perlfunc/cos>.
 233  See also L<Math::Trig>.
 234  
 235  =item cosh
 236  
 237  This is identical to the C function C<cosh()>, for returning
 238  the hyperbolic cosine of its numeric argument.  See also L<Math::Trig>.
 239  
 240  =item creat
 241  
 242  Create a new file.  This returns a file descriptor like the ones returned by
 243  C<POSIX::open>.  Use C<POSIX::close> to close the file.
 244  
 245      $fd = POSIX::creat( "foo", 0611 );
 246      POSIX::close( $fd );
 247  
 248  See also L<perlfunc/sysopen> and its C<O_CREAT> flag.
 249  
 250  =item ctermid
 251  
 252  Generates the path name for the controlling terminal.
 253  
 254      $path = POSIX::ctermid();
 255  
 256  =item ctime
 257  
 258  This is identical to the C function C<ctime()> and equivalent
 259  to C<asctime(localtime(...))>, see L</asctime> and L</localtime>.
 260  
 261  =item cuserid
 262  
 263  Get the login name of the owner of the current process.
 264  
 265      $name = POSIX::cuserid();
 266  
 267  =item difftime
 268  
 269  This is identical to the C function C<difftime()>, for returning
 270  the time difference (in seconds) between two times (as returned
 271  by C<time()>), see L</time>.
 272  
 273  =item div
 274  
 275  div() is C-specific, use L<perlfunc/int> on the usual C</> division and
 276  the modulus C<%>.
 277  
 278  =item dup
 279  
 280  This is similar to the C function C<dup()>, for duplicating a file
 281  descriptor.
 282  
 283  This uses file descriptors such as those obtained by calling
 284  C<POSIX::open>.
 285  
 286  Returns C<undef> on failure.
 287  
 288  =item dup2
 289  
 290  This is similar to the C function C<dup2()>, for duplicating a file
 291  descriptor to an another known file descriptor.
 292  
 293  This uses file descriptors such as those obtained by calling
 294  C<POSIX::open>.
 295  
 296  Returns C<undef> on failure.
 297  
 298  =item errno
 299  
 300  Returns the value of errno.
 301  
 302      $errno = POSIX::errno();
 303  
 304  This identical to the numerical values of the C<$!>, see L<perlvar/$ERRNO>.
 305  
 306  =item execl
 307  
 308  execl() is C-specific, see L<perlfunc/exec>.
 309  
 310  =item execle
 311  
 312  execle() is C-specific, see L<perlfunc/exec>.
 313  
 314  =item execlp
 315  
 316  execlp() is C-specific, see L<perlfunc/exec>.
 317  
 318  =item execv
 319  
 320  execv() is C-specific, see L<perlfunc/exec>.
 321  
 322  =item execve
 323  
 324  execve() is C-specific, see L<perlfunc/exec>.
 325  
 326  =item execvp
 327  
 328  execvp() is C-specific, see L<perlfunc/exec>.
 329  
 330  =item exit
 331  
 332  This is identical to Perl's builtin C<exit()> function for exiting the
 333  program, see L<perlfunc/exit>.
 334  
 335  =item exp
 336  
 337  This is identical to Perl's builtin C<exp()> function for
 338  returning the exponent (I<e>-based) of the numerical argument,
 339  see L<perlfunc/exp>.
 340  
 341  =item fabs
 342  
 343  This is identical to Perl's builtin C<abs()> function for returning
 344  the absolute value of the numerical argument, see L<perlfunc/abs>.
 345  
 346  =item fclose
 347  
 348  Use method C<IO::Handle::close()> instead, or see L<perlfunc/close>.
 349  
 350  =item fcntl
 351  
 352  This is identical to Perl's builtin C<fcntl()> function,
 353  see L<perlfunc/fcntl>.
 354  
 355  =item fdopen
 356  
 357  Use method C<IO::Handle::new_from_fd()> instead, or see L<perlfunc/open>.
 358  
 359  =item feof
 360  
 361  Use method C<IO::Handle::eof()> instead, or see L<perlfunc/eof>.
 362  
 363  =item ferror
 364  
 365  Use method C<IO::Handle::error()> instead.
 366  
 367  =item fflush
 368  
 369  Use method C<IO::Handle::flush()> instead.
 370  See also L<perlvar/$OUTPUT_AUTOFLUSH>.
 371  
 372  =item fgetc
 373  
 374  Use method C<IO::Handle::getc()> instead, or see L<perlfunc/read>.
 375  
 376  =item fgetpos
 377  
 378  Use method C<IO::Seekable::getpos()> instead, or see L<L/seek>.
 379  
 380  =item fgets
 381  
 382  Use method C<IO::Handle::gets()> instead.  Similar to E<lt>E<gt>, also known
 383  as L<perlfunc/readline>.
 384  
 385  =item fileno
 386  
 387  Use method C<IO::Handle::fileno()> instead, or see L<perlfunc/fileno>.
 388  
 389  =item floor
 390  
 391  This is identical to the C function C<floor()>, returning the largest
 392  integer value less than or equal to the numerical argument.
 393  
 394  =item fmod
 395  
 396  This is identical to the C function C<fmod()>.
 397  
 398      $r = fmod($x, $y);
 399  
 400  It returns the remainder C<$r = $x - $n*$y>, where C<$n = trunc($x/$y)>.
 401  The C<$r> has the same sign as C<$x> and magnitude (absolute value)
 402  less than the magnitude of C<$y>.
 403  
 404  =item fopen
 405  
 406  Use method C<IO::File::open()> instead, or see L<perlfunc/open>.
 407  
 408  =item fork
 409  
 410  This is identical to Perl's builtin C<fork()> function
 411  for duplicating the current process, see L<perlfunc/fork>
 412  and L<perlfork> if you are in Windows.
 413  
 414  =item fpathconf
 415  
 416  Retrieves the value of a configurable limit on a file or directory.  This
 417  uses file descriptors such as those obtained by calling C<POSIX::open>.
 418  
 419  The following will determine the maximum length of the longest allowable
 420  pathname on the filesystem which holds C</var/foo>.
 421  
 422      $fd = POSIX::open( "/var/foo", &POSIX::O_RDONLY );
 423      $path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX );
 424  
 425  Returns C<undef> on failure.
 426  
 427  =item fprintf
 428  
 429  fprintf() is C-specific, see L<perlfunc/printf> instead.
 430  
 431  =item fputc
 432  
 433  fputc() is C-specific, see L<perlfunc/print> instead.
 434  
 435  =item fputs
 436  
 437  fputs() is C-specific, see L<perlfunc/print> instead.
 438  
 439  =item fread
 440  
 441  fread() is C-specific, see L<perlfunc/read> instead.
 442  
 443  =item free
 444  
 445  free() is C-specific.  Perl does memory management transparently.
 446  
 447  =item freopen
 448  
 449  freopen() is C-specific, see L<perlfunc/open> instead.
 450  
 451  =item frexp
 452  
 453  Return the mantissa and exponent of a floating-point number.
 454  
 455      ($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
 456  
 457  =item fscanf
 458  
 459  fscanf() is C-specific, use E<lt>E<gt> and regular expressions instead.
 460  
 461  =item fseek
 462  
 463  Use method C<IO::Seekable::seek()> instead, or see L<perlfunc/seek>.
 464  
 465  =item fsetpos
 466  
 467  Use method C<IO::Seekable::setpos()> instead, or seek L<perlfunc/seek>.
 468  
 469  =item fstat
 470  
 471  Get file status.  This uses file descriptors such as those obtained by
 472  calling C<POSIX::open>.  The data returned is identical to the data from
 473  Perl's builtin C<stat> function.
 474  
 475      $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
 476      @stats = POSIX::fstat( $fd );
 477  
 478  =item fsync
 479  
 480  Use method C<IO::Handle::sync()> instead.
 481  
 482  =item ftell
 483  
 484  Use method C<IO::Seekable::tell()> instead, or see L<perlfunc/tell>.
 485  
 486  =item fwrite
 487  
 488  fwrite() is C-specific, see L<perlfunc/print> instead.
 489  
 490  =item getc
 491  
 492  This is identical to Perl's builtin C<getc()> function,
 493  see L<perlfunc/getc>.
 494  
 495  =item getchar
 496  
 497  Returns one character from STDIN.  Identical to Perl's C<getc()>,
 498  see L<perlfunc/getc>.
 499  
 500  =item getcwd
 501  
 502  Returns the name of the current working directory.
 503  See also L<Cwd>.
 504  
 505  =item getegid
 506  
 507  Returns the effective group identifier.  Similar to Perl' s builtin
 508  variable C<$(>, see L<perlvar/$EGID>.
 509  
 510  =item getenv
 511  
 512  Returns the value of the specified environment variable.
 513  The same information is available through the C<%ENV> array.
 514  
 515  =item geteuid
 516  
 517  Returns the effective user identifier.  Identical to Perl's builtin C<$E<gt>>
 518  variable, see L<perlvar/$EUID>.
 519  
 520  =item getgid
 521  
 522  Returns the user's real group identifier.  Similar to Perl's builtin
 523  variable C<$)>, see L<perlvar/$GID>.
 524  
 525  =item getgrgid
 526  
 527  This is identical to Perl's builtin C<getgrgid()> function for
 528  returning group entries by group identifiers, see
 529  L<perlfunc/getgrgid>.
 530  
 531  =item getgrnam
 532  
 533  This is identical to Perl's builtin C<getgrnam()> function for
 534  returning group entries by group names, see L<perlfunc/getgrnam>.
 535  
 536  =item getgroups
 537  
 538  Returns the ids of the user's supplementary groups.  Similar to Perl's
 539  builtin variable C<$)>, see L<perlvar/$GID>.
 540  
 541  =item getlogin
 542  
 543  This is identical to Perl's builtin C<getlogin()> function for
 544  returning the user name associated with the current session, see
 545  L<perlfunc/getlogin>.
 546  
 547  =item getpgrp
 548  
 549  This is identical to Perl's builtin C<getpgrp()> function for
 550  returning the process group identifier of the current process, see
 551  L<perlfunc/getpgrp>.
 552  
 553  =item getpid
 554  
 555  Returns the process identifier.  Identical to Perl's builtin
 556  variable C<$$>, see L<perlvar/$PID>.
 557  
 558  =item getppid
 559  
 560  This is identical to Perl's builtin C<getppid()> function for
 561  returning the process identifier of the parent process of the current
 562  process , see L<perlfunc/getppid>.
 563  
 564  =item getpwnam
 565  
 566  This is identical to Perl's builtin C<getpwnam()> function for
 567  returning user entries by user names, see L<perlfunc/getpwnam>.
 568  
 569  =item getpwuid
 570  
 571  This is identical to Perl's builtin C<getpwuid()> function for
 572  returning user entries by user identifiers, see L<perlfunc/getpwuid>.
 573  
 574  =item gets
 575  
 576  Returns one line from C<STDIN>, similar to E<lt>E<gt>, also known
 577  as the C<readline()> function, see L<perlfunc/readline>.
 578  
 579  B<NOTE>: if you have C programs that still use C<gets()>, be very
 580  afraid.  The C<gets()> function is a source of endless grief because
 581  it has no buffer overrun checks.  It should B<never> be used.  The
 582  C<fgets()> function should be preferred instead.
 583  
 584  =item getuid
 585  
 586  Returns the user's identifier.  Identical to Perl's builtin C<$E<lt>> variable,
 587  see L<perlvar/$UID>.
 588  
 589  =item gmtime
 590  
 591  This is identical to Perl's builtin C<gmtime()> function for
 592  converting seconds since the epoch to a date in Greenwich Mean Time,
 593  see L<perlfunc/gmtime>.
 594  
 595  =item isalnum
 596  
 597  This is identical to the C function, except that it can apply to a
 598  single character or to a whole string.  Note that locale settings may
 599  affect what characters are considered C<isalnum>.  Does not work on
 600  Unicode characters code point 256 or higher.  Consider using regular
 601  expressions and the C</[[:alnum:]]/> construct instead, or possibly
 602  the C</\w/> construct.
 603  
 604  =item isalpha
 605  
 606  This is identical to the C function, except that it can apply to
 607  a single character or to a whole string.  Note that locale settings
 608  may affect what characters are considered C<isalpha>.  Does not work
 609  on Unicode characters code point 256 or higher.  Consider using regular
 610  expressions and the C</[[:alpha:]]/> construct instead.
 611  
 612  =item isatty
 613  
 614  Returns a boolean indicating whether the specified filehandle is connected
 615  to a tty.  Similar to the C<-t> operator, see L<perlfunc/-X>.
 616  
 617  =item iscntrl
 618  
 619  This is identical to the C function, except that it can apply to
 620  a single character or to a whole string.  Note that locale settings
 621  may affect what characters are considered C<iscntrl>.  Does not work
 622  on Unicode characters code point 256 or higher.  Consider using regular
 623  expressions and the C</[[:cntrl:]]/> construct instead.
 624  
 625  =item isdigit
 626  
 627  This is identical to the C function, except that it can apply to
 628  a single character or to a whole string.  Note that locale settings
 629  may affect what characters are considered C<isdigit> (unlikely, but
 630  still possible). Does not work on Unicode characters code point 256
 631  or higher.  Consider using regular expressions and the C</[[:digit:]]/>
 632  construct instead, or the C</\d/> construct.
 633  
 634  =item isgraph
 635  
 636  This is identical to the C function, except that it can apply to
 637  a single character or to a whole string.  Note that locale settings
 638  may affect what characters are considered C<isgraph>.  Does not work
 639  on Unicode characters code point 256 or higher.  Consider using regular
 640  expressions and the C</[[:graph:]]/> construct instead.
 641  
 642  =item islower
 643  
 644  This is identical to the C function, except that it can apply to
 645  a single character or to a whole string.  Note that locale settings
 646  may affect what characters are considered C<islower>.  Does not work
 647  on Unicode characters code point 256 or higher.  Consider using regular
 648  expressions and the C</[[:lower:]]/> construct instead.  Do B<not> use
 649  C</[a-z]/>.
 650  
 651  =item isprint
 652  
 653  This is identical to the C function, except that it can apply to
 654  a single character or to a whole string.  Note that locale settings
 655  may affect what characters are considered C<isprint>.  Does not work
 656  on Unicode characters code point 256 or higher.  Consider using regular
 657  expressions and the C</[[:print:]]/> construct instead.
 658  
 659  =item ispunct
 660  
 661  This is identical to the C function, except that it can apply to
 662  a single character or to a whole string.  Note that locale settings
 663  may affect what characters are considered C<ispunct>.  Does not work
 664  on Unicode characters code point 256 or higher.  Consider using regular
 665  expressions and the C</[[:punct:]]/> construct instead.
 666  
 667  =item isspace
 668  
 669  This is identical to the C function, except that it can apply to
 670  a single character or to a whole string.  Note that locale settings
 671  may affect what characters are considered C<isspace>.  Does not work
 672  on Unicode characters code point 256 or higher.  Consider using regular
 673  expressions and the C</[[:space:]]/> construct instead, or the C</\s/>
 674  construct.  (Note that C</\s/> and C</[[:space:]]/> are slightly
 675  different in that C</[[:space:]]/> can normally match a vertical tab,
 676  while C</\s/> does not.)
 677  
 678  =item isupper
 679  
 680  This is identical to the C function, except that it can apply to
 681  a single character or to a whole string.  Note that locale settings
 682  may affect what characters are considered C<isupper>.  Does not work
 683  on Unicode characters code point 256 or higher.  Consider using regular
 684  expressions and the C</[[:upper:]]/> construct instead.  Do B<not> use
 685  C</[A-Z]/>.
 686  
 687  =item isxdigit
 688  
 689  This is identical to the C function, except that it can apply to a single
 690  character or to a whole string.  Note that locale settings may affect what
 691  characters are considered C<isxdigit> (unlikely, but still possible).
 692  Does not work on Unicode characters code point 256 or higher.
 693  Consider using regular expressions and the C</[[:xdigit:]]/>
 694  construct instead, or simply C</[0-9a-f]/i>.
 695  
 696  =item kill
 697  
 698  This is identical to Perl's builtin C<kill()> function for sending
 699  signals to processes (often to terminate them), see L<perlfunc/kill>.
 700  
 701  =item labs
 702  
 703  (For returning absolute values of long integers.)
 704  labs() is C-specific, see L<perlfunc/abs> instead.
 705  
 706  =item ldexp
 707  
 708  This is identical to the C function C<ldexp()>
 709  for multiplying floating point numbers with powers of two.
 710  
 711      $x_quadrupled = POSIX::ldexp($x, 2);
 712  
 713  =item ldiv
 714  
 715  (For computing dividends of long integers.)
 716  ldiv() is C-specific, use C</> and C<int()> instead.
 717  
 718  =item link
 719  
 720  This is identical to Perl's builtin C<link()> function
 721  for creating hard links into files, see L<perlfunc/link>.
 722  
 723  =item localeconv
 724  
 725  Get numeric formatting information.  Returns a reference to a hash
 726  containing the current locale formatting values.
 727  
 728  Here is how to query the database for the B<de> (Deutsch or German) locale.
 729  
 730      $loc = POSIX::setlocale( &POSIX::LC_ALL, "de" );
 731      print "Locale = $loc\n";
 732      $lconv = POSIX::localeconv();
 733      print "decimal_point    = ", $lconv->{decimal_point},    "\n";
 734      print "thousands_sep    = ", $lconv->{thousands_sep},    "\n";
 735      print "grouping    = ", $lconv->{grouping},    "\n";
 736      print "int_curr_symbol    = ", $lconv->{int_curr_symbol},    "\n";
 737      print "currency_symbol    = ", $lconv->{currency_symbol},    "\n";
 738      print "mon_decimal_point = ", $lconv->{mon_decimal_point}, "\n";
 739      print "mon_thousands_sep = ", $lconv->{mon_thousands_sep}, "\n";
 740      print "mon_grouping    = ", $lconv->{mon_grouping},    "\n";
 741      print "positive_sign    = ", $lconv->{positive_sign},    "\n";
 742      print "negative_sign    = ", $lconv->{negative_sign},    "\n";
 743      print "int_frac_digits    = ", $lconv->{int_frac_digits},    "\n";
 744      print "frac_digits    = ", $lconv->{frac_digits},    "\n";
 745      print "p_cs_precedes    = ", $lconv->{p_cs_precedes},    "\n";
 746      print "p_sep_by_space    = ", $lconv->{p_sep_by_space},    "\n";
 747      print "n_cs_precedes    = ", $lconv->{n_cs_precedes},    "\n";
 748      print "n_sep_by_space    = ", $lconv->{n_sep_by_space},    "\n";
 749      print "p_sign_posn    = ", $lconv->{p_sign_posn},    "\n";
 750      print "n_sign_posn    = ", $lconv->{n_sign_posn},    "\n";
 751  
 752  =item localtime
 753  
 754  This is identical to Perl's builtin C<localtime()> function for
 755  converting seconds since the epoch to a date see L<perlfunc/localtime>.
 756  
 757  =item log
 758  
 759  This is identical to Perl's builtin C<log()> function,
 760  returning the natural (I<e>-based) logarithm of the numerical argument,
 761  see L<perlfunc/log>.
 762  
 763  =item log10
 764  
 765  This is identical to the C function C<log10()>,
 766  returning the 10-base logarithm of the numerical argument.
 767  You can also use
 768  
 769      sub log10 { log($_[0]) / log(10) }
 770  
 771  or
 772  
 773      sub log10 { log($_[0]) / 2.30258509299405 }
 774  
 775  or
 776  
 777      sub log10 { log($_[0]) * 0.434294481903252 }
 778  
 779  =item longjmp
 780  
 781  longjmp() is C-specific: use L<perlfunc/die> instead.
 782  
 783  =item lseek
 784  
 785  Move the file's read/write position.  This uses file descriptors such as
 786  those obtained by calling C<POSIX::open>.
 787  
 788      $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
 789      $off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
 790  
 791  Returns C<undef> on failure.
 792  
 793  =item malloc
 794  
 795  malloc() is C-specific.  Perl does memory management transparently.
 796  
 797  =item mblen
 798  
 799  This is identical to the C function C<mblen()>.
 800  Perl does not have any support for the wide and multibyte
 801  characters of the C standards, so this might be a rather
 802  useless function.
 803  
 804  =item mbstowcs
 805  
 806  This is identical to the C function C<mbstowcs()>.
 807  Perl does not have any support for the wide and multibyte
 808  characters of the C standards, so this might be a rather
 809  useless function.
 810  
 811  =item mbtowc
 812  
 813  This is identical to the C function C<mbtowc()>.
 814  Perl does not have any support for the wide and multibyte
 815  characters of the C standards, so this might be a rather
 816  useless function.
 817  
 818  =item memchr
 819  
 820  memchr() is C-specific, see L<perlfunc/index> instead.
 821  
 822  =item memcmp
 823  
 824  memcmp() is C-specific, use C<eq> instead, see L<perlop>.
 825  
 826  =item memcpy
 827  
 828  memcpy() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
 829  
 830  =item memmove
 831  
 832  memmove() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
 833  
 834  =item memset
 835  
 836  memset() is C-specific, use C<x> instead, see L<perlop>.
 837  
 838  =item mkdir
 839  
 840  This is identical to Perl's builtin C<mkdir()> function
 841  for creating directories, see L<perlfunc/mkdir>.
 842  
 843  =item mkfifo
 844  
 845  This is similar to the C function C<mkfifo()> for creating
 846  FIFO special files.
 847  
 848      if (mkfifo($path, $mode)) { ....
 849  
 850  Returns C<undef> on failure.  The C<$mode> is similar to the
 851  mode of C<mkdir()>, see L<perlfunc/mkdir>, though for C<mkfifo>
 852  you B<must> specify the C<$mode>.
 853  
 854  =item mktime
 855  
 856  Convert date/time info to a calendar time.
 857  
 858  Synopsis:
 859  
 860      mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = -1)
 861  
 862  The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
 863  I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1.  The
 864  year (C<year>) is given in years since 1900.  I.e. The year 1995 is 95; the
 865  year 2001 is 101.  Consult your system's C<mktime()> manpage for details
 866  about these and the other arguments.
 867  
 868  Calendar time for December 12, 1995, at 10:30 am.
 869  
 870      $time_t = POSIX::mktime( 0, 30, 10, 12, 11, 95 );
 871      print "Date = ", POSIX::ctime($time_t);
 872  
 873  Returns C<undef> on failure.
 874  
 875  =item modf
 876  
 877  Return the integral and fractional parts of a floating-point number.
 878  
 879      ($fractional, $integral) = POSIX::modf( 3.14 );
 880  
 881  =item nice
 882  
 883  This is similar to the C function C<nice()>, for changing
 884  the scheduling preference of the current process.  Positive
 885  arguments mean more polite process, negative values more
 886  needy process.  Normal user processes can only be more polite.
 887  
 888  Returns C<undef> on failure.
 889  
 890  =item offsetof
 891  
 892  offsetof() is C-specific, you probably want to see L<perlfunc/pack> instead.
 893  
 894  =item open
 895  
 896  Open a file for reading for writing.  This returns file descriptors, not
 897  Perl filehandles.  Use C<POSIX::close> to close the file.
 898  
 899  Open a file read-only with mode 0666.
 900  
 901      $fd = POSIX::open( "foo" );
 902  
 903  Open a file for read and write.
 904  
 905      $fd = POSIX::open( "foo", &POSIX::O_RDWR );
 906  
 907  Open a file for write, with truncation.
 908  
 909      $fd = POSIX::open( "foo", &POSIX::O_WRONLY | &POSIX::O_TRUNC );
 910  
 911  Create a new file with mode 0640.  Set up the file for writing.
 912  
 913      $fd = POSIX::open( "foo", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640 );
 914  
 915  Returns C<undef> on failure.
 916  
 917  See also L<perlfunc/sysopen>.
 918  
 919  =item opendir
 920  
 921  Open a directory for reading.
 922  
 923      $dir = POSIX::opendir( "/var" );
 924      @files = POSIX::readdir( $dir );
 925      POSIX::closedir( $dir );
 926  
 927  Returns C<undef> on failure.
 928  
 929  =item pathconf
 930  
 931  Retrieves the value of a configurable limit on a file or directory.
 932  
 933  The following will determine the maximum length of the longest allowable
 934  pathname on the filesystem which holds C</var>.
 935  
 936      $path_max = POSIX::pathconf( "/var", &POSIX::_PC_PATH_MAX );
 937  
 938  Returns C<undef> on failure.
 939  
 940  =item pause
 941  
 942  This is similar to the C function C<pause()>, which suspends
 943  the execution of the current process until a signal is received.
 944  
 945  Returns C<undef> on failure.
 946  
 947  =item perror
 948  
 949  This is identical to the C function C<perror()>, which outputs to the
 950  standard error stream the specified message followed by ": " and the
 951  current error string.  Use the C<warn()> function and the C<$!>
 952  variable instead, see L<perlfunc/warn> and L<perlvar/$ERRNO>.
 953  
 954  =item pipe
 955  
 956  Create an interprocess channel.  This returns file descriptors like those
 957  returned by C<POSIX::open>.
 958  
 959      my ($read, $write) = POSIX::pipe();
 960      POSIX::write( $write, "hello", 5 );
 961      POSIX::read( $read, $buf, 5 );
 962  
 963  See also L<perlfunc/pipe>.
 964  
 965  =item pow
 966  
 967  Computes C<$x> raised to the power C<$exponent>.
 968  
 969      $ret = POSIX::pow( $x, $exponent );
 970  
 971  You can also use the C<**> operator, see L<perlop>.
 972  
 973  =item printf
 974  
 975  Formats and prints the specified arguments to STDOUT.
 976  See also L<perlfunc/printf>.
 977  
 978  =item putc
 979  
 980  putc() is C-specific, see L<perlfunc/print> instead.
 981  
 982  =item putchar
 983  
 984  putchar() is C-specific, see L<perlfunc/print> instead.
 985  
 986  =item puts
 987  
 988  puts() is C-specific, see L<perlfunc/print> instead.
 989  
 990  =item qsort
 991  
 992  qsort() is C-specific, see L<perlfunc/sort> instead.
 993  
 994  =item raise
 995  
 996  Sends the specified signal to the current process.
 997  See also L<perlfunc/kill> and the C<$$> in L<perlvar/$PID>.
 998  
 999  =item rand
1000  
1001  C<rand()> is non-portable, see L<perlfunc/rand> instead.
1002  
1003  =item read
1004  
1005  Read from a file.  This uses file descriptors such as those obtained by
1006  calling C<POSIX::open>.  If the buffer C<$buf> is not large enough for the
1007  read then Perl will extend it to make room for the request.
1008  
1009      $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
1010      $bytes = POSIX::read( $fd, $buf, 3 );
1011  
1012  Returns C<undef> on failure.
1013  
1014  See also L<perlfunc/sysread>.
1015  
1016  =item readdir
1017  
1018  This is identical to Perl's builtin C<readdir()> function
1019  for reading directory entries, see L<perlfunc/readdir>.
1020  
1021  =item realloc
1022  
1023  realloc() is C-specific.  Perl does memory management transparently.
1024  
1025  =item remove
1026  
1027  This is identical to Perl's builtin C<unlink()> function
1028  for removing files, see L<perlfunc/unlink>.
1029  
1030  =item rename
1031  
1032  This is identical to Perl's builtin C<rename()> function
1033  for renaming files, see L<perlfunc/rename>.
1034  
1035  =item rewind
1036  
1037  Seeks to the beginning of the file.
1038  
1039  =item rewinddir
1040  
1041  This is identical to Perl's builtin C<rewinddir()> function for
1042  rewinding directory entry streams, see L<perlfunc/rewinddir>.
1043  
1044  =item rmdir
1045  
1046  This is identical to Perl's builtin C<rmdir()> function
1047  for removing (empty) directories, see L<perlfunc/rmdir>.
1048  
1049  =item scanf
1050  
1051  scanf() is C-specific, use E<lt>E<gt> and regular expressions instead,
1052  see L<perlre>.
1053  
1054  =item setgid
1055  
1056  Sets the real group identifier and the effective group identifier for
1057  this process.  Similar to assigning a value to the Perl's builtin
1058  C<$)> variable, see L<perlvar/$EGID>, except that the latter
1059  will change only the real user identifier, and that the setgid()
1060  uses only a single numeric argument, as opposed to a space-separated
1061  list of numbers.
1062  
1063  =item setjmp
1064  
1065  C<setjmp()> is C-specific: use C<eval {}> instead,
1066  see L<perlfunc/eval>.
1067  
1068  =item setlocale
1069  
1070  Modifies and queries program's locale.  The following examples assume
1071  
1072      use POSIX qw(setlocale LC_ALL LC_CTYPE);
1073  
1074  has been issued.
1075  
1076  The following will set the traditional UNIX system locale behavior
1077  (the second argument C<"C">).
1078  
1079      $loc = setlocale( LC_ALL, "C" );
1080  
1081  The following will query the current LC_CTYPE category.  (No second
1082  argument means 'query'.)
1083  
1084      $loc = setlocale( LC_CTYPE );
1085  
1086  The following will set the LC_CTYPE behaviour according to the locale
1087  environment variables (the second argument C<"">).
1088  Please see your systems C<setlocale(3)> documentation for the locale
1089  environment variables' meaning or consult L<perllocale>.
1090  
1091      $loc = setlocale( LC_CTYPE, "" );
1092  
1093  The following will set the LC_COLLATE behaviour to Argentinian
1094  Spanish. B<NOTE>: The naming and availability of locales depends on
1095  your operating system. Please consult L<perllocale> for how to find
1096  out which locales are available in your system.
1097  
1098      $loc = setlocale( LC_ALL, "es_AR.ISO8859-1" );
1099  
1100  =item setpgid
1101  
1102  This is similar to the C function C<setpgid()> for
1103  setting the process group identifier of the current process.
1104  
1105  Returns C<undef> on failure.
1106  
1107  =item setsid
1108  
1109  This is identical to the C function C<setsid()> for
1110  setting the session identifier of the current process.
1111  
1112  =item setuid
1113  
1114  Sets the real user identifier and the effective user identifier for
1115  this process.  Similar to assigning a value to the Perl's builtin
1116  C<$E<lt>> variable, see L<perlvar/$UID>, except that the latter
1117  will change only the real user identifier.
1118  
1119  =item sigaction
1120  
1121  Detailed signal management.  This uses C<POSIX::SigAction> objects for
1122  the C<action> and C<oldaction> arguments (the oldaction can also be
1123  just a hash reference).  Consult your system's C<sigaction> manpage
1124  for details, see also C<POSIX::SigRt>.
1125  
1126  Synopsis:
1127  
1128      sigaction(signal, action, oldaction = 0)
1129  
1130  Returns C<undef> on failure.  The C<signal> must be a number (like
1131  SIGHUP), not a string (like "SIGHUP"), though Perl does try hard
1132  to understand you.
1133  
1134  If you use the SA_SIGINFO flag, the signal handler will in addition to
1135  the first argument, the signal name, also receive a second argument, a
1136  hash reference, inside which are the following keys with the following
1137  semantics, as defined by POSIX/SUSv3:
1138  
1139      signo       the signal number
1140      errno       the error number
1141      code        if this is zero or less, the signal was sent by
1142                  a user process and the uid and pid make sense,
1143                  otherwise the signal was sent by the kernel
1144  
1145  The following are also defined by POSIX/SUSv3, but unfortunately
1146  not very widely implemented:
1147  
1148      pid         the process id generating the signal
1149      uid         the uid of the process id generating the signal
1150      status      exit value or signal for SIGCHLD
1151      band        band event for SIGPOLL
1152  
1153  A third argument is also passed to the handler, which contains a copy
1154  of the raw binary contents of the siginfo structure: if a system has
1155  some non-POSIX fields, this third argument is where to unpack() them
1156  from.
1157  
1158  Note that not all siginfo values make sense simultaneously (some are
1159  valid only for certain signals, for example), and not all values make
1160  sense from Perl perspective, you should to consult your system's
1161  C<sigaction> and possibly also C<siginfo> documentation.
1162  
1163  =item siglongjmp
1164  
1165  siglongjmp() is C-specific: use L<perlfunc/die> instead.
1166  
1167  =item sigpending
1168  
1169  Examine signals that are blocked and pending.  This uses C<POSIX::SigSet>
1170  objects for the C<sigset> argument.  Consult your system's C<sigpending>
1171  manpage for details.
1172  
1173  Synopsis:
1174  
1175      sigpending(sigset)
1176  
1177  Returns C<undef> on failure.
1178  
1179  =item sigprocmask
1180  
1181  Change and/or examine calling process's signal mask.  This uses
1182  C<POSIX::SigSet> objects for the C<sigset> and C<oldsigset> arguments.
1183  Consult your system's C<sigprocmask> manpage for details.
1184  
1185  Synopsis:
1186  
1187      sigprocmask(how, sigset, oldsigset = 0)
1188  
1189  Returns C<undef> on failure.
1190  
1191  =item sigsetjmp
1192  
1193  C<sigsetjmp()> is C-specific: use C<eval {}> instead,
1194  see L<perlfunc/eval>.
1195  
1196  =item sigsuspend
1197  
1198  Install a signal mask and suspend process until signal arrives.  This uses
1199  C<POSIX::SigSet> objects for the C<signal_mask> argument.  Consult your
1200  system's C<sigsuspend> manpage for details.
1201  
1202  Synopsis:
1203  
1204      sigsuspend(signal_mask)
1205  
1206  Returns C<undef> on failure.
1207  
1208  =item sin
1209  
1210  This is identical to Perl's builtin C<sin()> function
1211  for returning the sine of the numerical argument,
1212  see L<perlfunc/sin>.  See also L<Math::Trig>.
1213  
1214  =item sinh
1215  
1216  This is identical to the C function C<sinh()>
1217  for returning the hyperbolic sine of the numerical argument.
1218  See also L<Math::Trig>.
1219  
1220  =item sleep
1221  
1222  This is functionally identical to Perl's builtin C<sleep()> function
1223  for suspending the execution of the current for process for certain
1224  number of seconds, see L<perlfunc/sleep>.  There is one significant
1225  difference, however: C<POSIX::sleep()> returns the number of
1226  B<unslept> seconds, while the C<CORE::sleep()> returns the
1227  number of slept seconds.
1228  
1229  =item sprintf
1230  
1231  This is similar to Perl's builtin C<sprintf()> function
1232  for returning a string that has the arguments formatted as requested,
1233  see L<perlfunc/sprintf>.
1234  
1235  =item sqrt
1236  
1237  This is identical to Perl's builtin C<sqrt()> function.
1238  for returning the square root of the numerical argument,
1239  see L<perlfunc/sqrt>.
1240  
1241  =item srand
1242  
1243  Give a seed the pseudorandom number generator, see L<perlfunc/srand>.
1244  
1245  =item sscanf
1246  
1247  sscanf() is C-specific, use regular expressions instead,
1248  see L<perlre>.
1249  
1250  =item stat
1251  
1252  This is identical to Perl's builtin C<stat()> function
1253  for returning information about files and directories.
1254  
1255  =item strcat
1256  
1257  strcat() is C-specific, use C<.=> instead, see L<perlop>.
1258  
1259  =item strchr
1260  
1261  strchr() is C-specific, see L<perlfunc/index> instead.
1262  
1263  =item strcmp
1264  
1265  strcmp() is C-specific, use C<eq> or C<cmp> instead, see L<perlop>.
1266  
1267  =item strcoll
1268  
1269  This is identical to the C function C<strcoll()>
1270  for collating (comparing) strings transformed using
1271  the C<strxfrm()> function.  Not really needed since
1272  Perl can do this transparently, see L<perllocale>.
1273  
1274  =item strcpy
1275  
1276  strcpy() is C-specific, use C<=> instead, see L<perlop>.
1277  
1278  =item strcspn
1279  
1280  strcspn() is C-specific, use regular expressions instead,
1281  see L<perlre>.
1282  
1283  =item strerror
1284  
1285  Returns the error string for the specified errno.
1286  Identical to the string form of the C<$!>, see L<perlvar/$ERRNO>.
1287  
1288  =item strftime
1289  
1290  Convert date and time information to string.  Returns the string.
1291  
1292  Synopsis:
1293  
1294      strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
1295  
1296  The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
1297  I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1.  The
1298  year (C<year>) is given in years since 1900.  I.e., the year 1995 is 95; the
1299  year 2001 is 101.  Consult your system's C<strftime()> manpage for details
1300  about these and the other arguments.
1301  
1302  If you want your code to be portable, your format (C<fmt>) argument
1303  should use only the conversion specifiers defined by the ANSI C
1304  standard (C89, to play safe).  These are C<aAbBcdHIjmMpSUwWxXyYZ%>.
1305  But even then, the B<results> of some of the conversion specifiers are
1306  non-portable.  For example, the specifiers C<aAbBcpZ> change according
1307  to the locale settings of the user, and both how to set locales (the
1308  locale names) and what output to expect are non-standard.
1309  The specifier C<c> changes according to the timezone settings of the
1310  user and the timezone computation rules of the operating system.
1311  The C<Z> specifier is notoriously unportable since the names of
1312  timezones are non-standard. Sticking to the numeric specifiers is the
1313  safest route.
1314  
1315  The given arguments are made consistent as though by calling
1316  C<mktime()> before calling your system's C<strftime()> function,
1317  except that the C<isdst> value is not affected.
1318  
1319  The string for Tuesday, December 12, 1995.
1320  
1321      $str = POSIX::strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 );
1322      print "$str\n";
1323  
1324  =item strlen
1325  
1326  strlen() is C-specific, use C<length()> instead, see L<perlfunc/length>.
1327  
1328  =item strncat
1329  
1330  strncat() is C-specific, use C<.=> instead, see L<perlop>.
1331  
1332  =item strncmp
1333  
1334  strncmp() is C-specific, use C<eq> instead, see L<perlop>.
1335  
1336  =item strncpy
1337  
1338  strncpy() is C-specific, use C<=> instead, see L<perlop>.
1339  
1340  =item strpbrk
1341  
1342  strpbrk() is C-specific, use regular expressions instead,
1343  see L<perlre>.
1344  
1345  =item strrchr
1346  
1347  strrchr() is C-specific, see L<perlfunc/rindex> instead.
1348  
1349  =item strspn
1350  
1351  strspn() is C-specific, use regular expressions instead,
1352  see L<perlre>.
1353  
1354  =item strstr
1355  
1356  This is identical to Perl's builtin C<index()> function,
1357  see L<perlfunc/index>.
1358  
1359  =item strtod
1360  
1361  String to double translation. Returns the parsed number and the number
1362  of characters in the unparsed portion of the string.  Truly
1363  POSIX-compliant systems set $! ($ERRNO) to indicate a translation
1364  error, so clear $! before calling strtod.  However, non-POSIX systems
1365  may not check for overflow, and therefore will never set $!.
1366  
1367  strtod should respect any POSIX I<setlocale()> settings.
1368  
1369  To parse a string $str as a floating point number use
1370  
1371      $! = 0;
1372      ($num, $n_unparsed) = POSIX::strtod($str);
1373  
1374  The second returned item and $! can be used to check for valid input:
1375  
1376      if (($str eq '') || ($n_unparsed != 0) || $!) {
1377          die "Non-numeric input $str" . ($! ? ": $!\n" : "\n");
1378      }
1379  
1380  When called in a scalar context strtod returns the parsed number.
1381  
1382  =item strtok
1383  
1384  strtok() is C-specific, use regular expressions instead, see
1385  L<perlre>, or L<perlfunc/split>.
1386  
1387  =item strtol
1388  
1389  String to (long) integer translation.  Returns the parsed number and
1390  the number of characters in the unparsed portion of the string.  Truly
1391  POSIX-compliant systems set $! ($ERRNO) to indicate a translation
1392  error, so clear $! before calling strtol.  However, non-POSIX systems
1393  may not check for overflow, and therefore will never set $!.
1394  
1395  strtol should respect any POSIX I<setlocale()> settings.
1396  
1397  To parse a string $str as a number in some base $base use
1398  
1399      $! = 0;
1400      ($num, $n_unparsed) = POSIX::strtol($str, $base);
1401  
1402  The base should be zero or between 2 and 36, inclusive.  When the base
1403  is zero or omitted strtol will use the string itself to determine the
1404  base: a leading "0x" or "0X" means hexadecimal; a leading "0" means
1405  octal; any other leading characters mean decimal.  Thus, "1234" is
1406  parsed as a decimal number, "01234" as an octal number, and "0x1234"
1407  as a hexadecimal number.
1408  
1409  The second returned item and $! can be used to check for valid input:
1410  
1411      if (($str eq '') || ($n_unparsed != 0) || !$!) {
1412          die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
1413      }
1414  
1415  When called in a scalar context strtol returns the parsed number.
1416  
1417  =item strtoul
1418  
1419  String to unsigned (long) integer translation.  strtoul() is identical
1420  to strtol() except that strtoul() only parses unsigned integers.  See
1421  L</strtol> for details.
1422  
1423  Note: Some vendors supply strtod() and strtol() but not strtoul().
1424  Other vendors that do supply strtoul() parse "-1" as a valid value.
1425  
1426  =item strxfrm
1427  
1428  String transformation.  Returns the transformed string.
1429  
1430      $dst = POSIX::strxfrm( $src );
1431  
1432  Used in conjunction with the C<strcoll()> function, see L</strcoll>.
1433  
1434  Not really needed since Perl can do this transparently, see
1435  L<perllocale>.
1436  
1437  =item sysconf
1438  
1439  Retrieves values of system configurable variables.
1440  
1441  The following will get the machine's clock speed.
1442  
1443      $clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
1444  
1445  Returns C<undef> on failure.
1446  
1447  =item system
1448  
1449  This is identical to Perl's builtin C<system()> function, see
1450  L<perlfunc/system>.
1451  
1452  =item tan
1453  
1454  This is identical to the C function C<tan()>, returning the
1455  tangent of the numerical argument.  See also L<Math::Trig>.
1456  
1457  =item tanh
1458  
1459  This is identical to the C function C<tanh()>, returning the
1460  hyperbolic tangent of the numerical argument.   See also L<Math::Trig>.
1461  
1462  =item tcdrain
1463  
1464  This is similar to the C function C<tcdrain()> for draining
1465  the output queue of its argument stream.
1466  
1467  Returns C<undef> on failure.
1468  
1469  =item tcflow
1470  
1471  This is similar to the C function C<tcflow()> for controlling
1472  the flow of its argument stream.
1473  
1474  Returns C<undef> on failure.
1475  
1476  =item tcflush
1477  
1478  This is similar to the C function C<tcflush()> for flushing
1479  the I/O buffers of its argument stream.
1480  
1481  Returns C<undef> on failure.
1482  
1483  =item tcgetpgrp
1484  
1485  This is identical to the C function C<tcgetpgrp()> for returning the
1486  process group identifier of the foreground process group of the controlling
1487  terminal.
1488  
1489  =item tcsendbreak
1490  
1491  This is similar to the C function C<tcsendbreak()> for sending
1492  a break on its argument stream.
1493  
1494  Returns C<undef> on failure.
1495  
1496  =item tcsetpgrp
1497  
1498  This is similar to the C function C<tcsetpgrp()> for setting the
1499  process group identifier of the foreground process group of the controlling
1500  terminal.
1501  
1502  Returns C<undef> on failure.
1503  
1504  =item time
1505  
1506  This is identical to Perl's builtin C<time()> function
1507  for returning the number of seconds since the epoch
1508  (whatever it is for the system), see L<perlfunc/time>.
1509  
1510  =item times
1511  
1512  The times() function returns elapsed realtime since some point in the past
1513  (such as system startup), user and system times for this process, and user
1514  and system times used by child processes.  All times are returned in clock
1515  ticks.
1516  
1517      ($realtime, $user, $system, $cuser, $csystem) = POSIX::times();
1518  
1519  Note: Perl's builtin C<times()> function returns four values, measured in
1520  seconds.
1521  
1522  =item tmpfile
1523  
1524  Use method C<IO::File::new_tmpfile()> instead, or see L<File::Temp>.
1525  
1526  =item tmpnam
1527  
1528  Returns a name for a temporary file.
1529  
1530      $tmpfile = POSIX::tmpnam();
1531  
1532  For security reasons, which are probably detailed in your system's
1533  documentation for the C library tmpnam() function, this interface
1534  should not be used; instead see L<File::Temp>.
1535  
1536  =item tolower
1537  
1538  This is identical to the C function, except that it can apply to a single
1539  character or to a whole string.  Consider using the C<lc()> function,
1540  see L<perlfunc/lc>, or the equivalent C<\L> operator inside doublequotish
1541  strings.
1542  
1543  =item toupper
1544  
1545  This is identical to the C function, except that it can apply to a single
1546  character or to a whole string.  Consider using the C<uc()> function,
1547  see L<perlfunc/uc>, or the equivalent C<\U> operator inside doublequotish
1548  strings.
1549  
1550  =item ttyname
1551  
1552  This is identical to the C function C<ttyname()> for returning the
1553  name of the current terminal.
1554  
1555  =item tzname
1556  
1557  Retrieves the time conversion information from the C<tzname> variable.
1558  
1559      POSIX::tzset();
1560      ($std, $dst) = POSIX::tzname();
1561  
1562  =item tzset
1563  
1564  This is identical to the C function C<tzset()> for setting
1565  the current timezone based on the environment variable C<TZ>,
1566  to be used by C<ctime()>, C<localtime()>, C<mktime()>, and C<strftime()>
1567  functions.
1568  
1569  =item umask
1570  
1571  This is identical to Perl's builtin C<umask()> function
1572  for setting (and querying) the file creation permission mask,
1573  see L<perlfunc/umask>.
1574  
1575  =item uname
1576  
1577  Get name of current operating system.
1578  
1579      ($sysname, $nodename, $release, $version, $machine) = POSIX::uname();
1580  
1581  Note that the actual meanings of the various fields are not
1582  that well standardized, do not expect any great portability.
1583  The C<$sysname> might be the name of the operating system,
1584  the C<$nodename> might be the name of the host, the C<$release>
1585  might be the (major) release number of the operating system,
1586  the C<$version> might be the (minor) release number of the
1587  operating system, and the C<$machine> might be a hardware identifier.
1588  Maybe.
1589  
1590  =item ungetc
1591  
1592  Use method C<IO::Handle::ungetc()> instead.
1593  
1594  =item unlink
1595  
1596  This is identical to Perl's builtin C<unlink()> function
1597  for removing files, see L<perlfunc/unlink>.
1598  
1599  =item utime
1600  
1601  This is identical to Perl's builtin C<utime()> function
1602  for changing the time stamps of files and directories,
1603  see L<perlfunc/utime>.
1604  
1605  =item vfprintf
1606  
1607  vfprintf() is C-specific, see L<perlfunc/printf> instead.
1608  
1609  =item vprintf
1610  
1611  vprintf() is C-specific, see L<perlfunc/printf> instead.
1612  
1613  =item vsprintf
1614  
1615  vsprintf() is C-specific, see L<perlfunc/sprintf> instead.
1616  
1617  =item wait
1618  
1619  This is identical to Perl's builtin C<wait()> function,
1620  see L<perlfunc/wait>.
1621  
1622  =item waitpid
1623  
1624  Wait for a child process to change state.  This is identical to Perl's
1625  builtin C<waitpid()> function, see L<perlfunc/waitpid>.
1626  
1627      $pid = POSIX::waitpid( -1, POSIX::WNOHANG );
1628      print "status = ", ($? / 256), "\n";
1629  
1630  =item wcstombs
1631  
1632  This is identical to the C function C<wcstombs()>.
1633  Perl does not have any support for the wide and multibyte
1634  characters of the C standards, so this might be a rather
1635  useless function.
1636  
1637  =item wctomb
1638  
1639  This is identical to the C function C<wctomb()>.
1640  Perl does not have any support for the wide and multibyte
1641  characters of the C standards, so this might be a rather
1642  useless function.
1643  
1644  =item write
1645  
1646  Write to a file.  This uses file descriptors such as those obtained by
1647  calling C<POSIX::open>.
1648  
1649      $fd = POSIX::open( "foo", &POSIX::O_WRONLY );
1650      $buf = "hello";
1651      $bytes = POSIX::write( $b, $buf, 5 );
1652  
1653  Returns C<undef> on failure.
1654  
1655  See also L<perlfunc/syswrite>.
1656  
1657  =back
1658  
1659  =head1 CLASSES
1660  
1661  =head2 POSIX::SigAction
1662  
1663  =over 8
1664  
1665  =item new
1666  
1667  Creates a new C<POSIX::SigAction> object which corresponds to the C
1668  C<struct sigaction>.  This object will be destroyed automatically when
1669  it is no longer needed.  The first parameter is the handler, a sub
1670  reference.  The second parameter is a C<POSIX::SigSet> object, it
1671  defaults to the empty set.  The third parameter contains the
1672  C<sa_flags>, it defaults to 0.
1673  
1674      $sigset = POSIX::SigSet->new(SIGINT, SIGQUIT);
1675      $sigaction = POSIX::SigAction->new( \&handler, $sigset, &POSIX::SA_NOCLDSTOP );
1676  
1677  This C<POSIX::SigAction> object is intended for use with the C<POSIX::sigaction()>
1678  function.
1679  
1680  =back
1681  
1682  =over 8
1683  
1684  =item handler
1685  
1686  =item mask
1687  
1688  =item flags
1689  
1690  accessor functions to get/set the values of a SigAction object.
1691  
1692      $sigset = $sigaction->mask;
1693      $sigaction->flags(&POSIX::SA_RESTART);
1694  
1695  =item safe
1696  
1697  accessor function for the "safe signals" flag of a SigAction object; see
1698  L<perlipc> for general information on safe (a.k.a. "deferred") signals.  If
1699  you wish to handle a signal safely, use this accessor to set the "safe" flag
1700  in the C<POSIX::SigAction> object:
1701  
1702      $sigaction->safe(1);
1703  
1704  You may also examine the "safe" flag on the output action object which is
1705  filled in when given as the third parameter to C<POSIX::sigaction()>:
1706  
1707      sigaction(SIGINT, $new_action, $old_action);
1708      if ($old_action->safe) {
1709          # previous SIGINT handler used safe signals
1710      }
1711  
1712  =back
1713  
1714  =head2 POSIX::SigRt
1715  
1716  =over 8
1717  
1718  =item %SIGRT
1719  
1720  A hash of the POSIX realtime signal handlers.  It is an extension of
1721  the standard %SIG, the $POSIX::SIGRT{SIGRTMIN} is roughly equivalent
1722  to $SIG{SIGRTMIN}, but the right POSIX moves (see below) are made with
1723  the POSIX::SigSet and POSIX::sigaction instead of accessing the %SIG.
1724  
1725  You can set the %POSIX::SIGRT elements to set the POSIX realtime
1726  signal handlers, use C<delete> and C<exists> on the elements, and use
1727  C<scalar> on the C<%POSIX::SIGRT> to find out how many POSIX realtime
1728  signals there are available (SIGRTMAX - SIGRTMIN + 1, the SIGRTMAX is
1729  a valid POSIX realtime signal).
1730  
1731  Setting the %SIGRT elements is equivalent to calling this:
1732  
1733    sub new {
1734      my ($rtsig, $handler, $flags) = @_;
1735      my $sigset = POSIX:SigSet($rtsig);
1736      my $sigact = POSIX::SigAction->new($handler, $sigset, $flags);
1737      sigaction($rtsig, $sigact);
1738    }
1739  
1740  The flags default to zero, if you want something different you can
1741  either use C<local> on $POSIX::RtSig::SIGACTION_FLAGS, or you can
1742  derive from POSIX::SigRt and define your own C<new()> (the tied hash
1743  STORE method of the %SIGRT calls C<new($rtsig, $handler, $SIGACTION_FLAGS)>,
1744  where the $rtsig ranges from zero to SIGRTMAX - SIGRTMIN + 1).
1745  
1746  Just as with any signal, you can use sigaction($rtsig, undef, $oa) to
1747  retrieve the installed signal handler (or, rather, the signal action).
1748  
1749  B<NOTE:> whether POSIX realtime signals really work in your system, or
1750  whether Perl has been compiled so that it works with them, is outside
1751  of this discussion.
1752  
1753  =item SIGRTMIN
1754  
1755  Return the minimum POSIX realtime signal number available, or C<undef>
1756  if no POSIX realtime signals are available.
1757  
1758  =item SIGRTMAX
1759  
1760  Return the maximum POSIX realtime signal number available, or C<undef>
1761  if no POSIX realtime signals are available.
1762  
1763  =back
1764  
1765  =head2 POSIX::SigSet
1766  
1767  =over 8
1768  
1769  =item new
1770  
1771  Create a new SigSet object.  This object will be destroyed automatically
1772  when it is no longer needed.  Arguments may be supplied to initialize the
1773  set.
1774  
1775  Create an empty set.
1776  
1777      $sigset = POSIX::SigSet->new;
1778  
1779  Create a set with SIGUSR1.
1780  
1781      $sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 );
1782  
1783  =item addset
1784  
1785  Add a signal to a SigSet object.
1786  
1787      $sigset->addset( &POSIX::SIGUSR2 );
1788  
1789  Returns C<undef> on failure.
1790  
1791  =item delset
1792  
1793  Remove a signal from the SigSet object.
1794  
1795      $sigset->delset( &POSIX::SIGUSR2 );
1796  
1797  Returns C<undef> on failure.
1798  
1799  =item emptyset
1800  
1801  Initialize the SigSet object to be empty.
1802  
1803      $sigset->emptyset();
1804  
1805  Returns C<undef> on failure.
1806  
1807  =item fillset
1808  
1809  Initialize the SigSet object to include all signals.
1810  
1811      $sigset->fillset();
1812  
1813  Returns C<undef> on failure.
1814  
1815  =item ismember
1816  
1817  Tests the SigSet object to see if it contains a specific signal.
1818  
1819      if( $sigset->ismember( &POSIX::SIGUSR1 ) ){
1820          print "contains SIGUSR1\n";
1821      }
1822  
1823  =back
1824  
1825  =head2 POSIX::Termios
1826  
1827  =over 8
1828  
1829  =item new
1830  
1831  Create a new Termios object.  This object will be destroyed automatically
1832  when it is no longer needed.  A Termios object corresponds to the termios
1833  C struct.  new() mallocs a new one, getattr() fills it from a file descriptor,
1834  and setattr() sets a file descriptor's parameters to match Termios' contents.
1835  
1836      $termios = POSIX::Termios->new;
1837  
1838  =item getattr
1839  
1840  Get terminal control attributes.
1841  
1842  Obtain the attributes for stdin.
1843  
1844      $termios->getattr( 0 ) # Recommended for clarity.
1845      $termios->getattr()
1846  
1847  Obtain the attributes for stdout.
1848  
1849      $termios->getattr( 1 )
1850  
1851  Returns C<undef> on failure.
1852  
1853  =item getcc
1854  
1855  Retrieve a value from the c_cc field of a termios object.  The c_cc field is
1856  an array so an index must be specified.
1857  
1858      $c_cc[1] = $termios->getcc(1);
1859  
1860  =item getcflag
1861  
1862  Retrieve the c_cflag field of a termios object.
1863  
1864      $c_cflag = $termios->getcflag;
1865  
1866  =item getiflag
1867  
1868  Retrieve the c_iflag field of a termios object.
1869  
1870      $c_iflag = $termios->getiflag;
1871  
1872  =item getispeed
1873  
1874  Retrieve the input baud rate.
1875  
1876      $ispeed = $termios->getispeed;
1877  
1878  =item getlflag
1879  
1880  Retrieve the c_lflag field of a termios object.
1881  
1882      $c_lflag = $termios->getlflag;
1883  
1884  =item getoflag
1885  
1886  Retrieve the c_oflag field of a termios object.
1887  
1888      $c_oflag = $termios->getoflag;
1889  
1890  =item getospeed
1891  
1892  Retrieve the output baud rate.
1893  
1894      $ospeed = $termios->getospeed;
1895  
1896  =item setattr
1897  
1898  Set terminal control attributes.
1899  
1900  Set attributes immediately for stdout.
1901  
1902      $termios->setattr( 1, &POSIX::TCSANOW );
1903  
1904  Returns C<undef> on failure.
1905  
1906  =item setcc
1907  
1908  Set a value in the c_cc field of a termios object.  The c_cc field is an
1909  array so an index must be specified.
1910  
1911      $termios->setcc( &POSIX::VEOF, 1 );
1912  
1913  =item setcflag
1914  
1915  Set the c_cflag field of a termios object.
1916  
1917      $termios->setcflag( $c_cflag | &POSIX::CLOCAL );
1918  
1919  =item setiflag
1920  
1921  Set the c_iflag field of a termios object.
1922  
1923      $termios->setiflag( $c_iflag | &POSIX::BRKINT );
1924  
1925  =item setispeed
1926  
1927  Set the input baud rate.
1928  
1929      $termios->setispeed( &POSIX::B9600 );
1930  
1931  Returns C<undef> on failure.
1932  
1933  =item setlflag
1934  
1935  Set the c_lflag field of a termios object.
1936  
1937      $termios->setlflag( $c_lflag | &POSIX::ECHO );
1938  
1939  =item setoflag
1940  
1941  Set the c_oflag field of a termios object.
1942  
1943      $termios->setoflag( $c_oflag | &POSIX::OPOST );
1944  
1945  =item setospeed
1946  
1947  Set the output baud rate.
1948  
1949      $termios->setospeed( &POSIX::B9600 );
1950  
1951  Returns C<undef> on failure.
1952  
1953  =item Baud rate values
1954  
1955  B38400 B75 B200 B134 B300 B1800 B150 B0 B19200 B1200 B9600 B600 B4800 B50 B2400 B110
1956  
1957  =item Terminal interface values
1958  
1959  TCSADRAIN TCSANOW TCOON TCIOFLUSH TCOFLUSH TCION TCIFLUSH TCSAFLUSH TCIOFF TCOOFF
1960  
1961  =item c_cc field values
1962  
1963  VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS
1964  
1965  =item c_cflag field values
1966  
1967  CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD
1968  
1969  =item c_iflag field values
1970  
1971  BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK
1972  
1973  =item c_lflag field values
1974  
1975  ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP
1976  
1977  =item c_oflag field values
1978  
1979  OPOST
1980  
1981  =back
1982  
1983  =head1 PATHNAME CONSTANTS
1984  
1985  =over 8
1986  
1987  =item Constants
1988  
1989  _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX _PC_PIPE_BUF _PC_VDISABLE
1990  
1991  =back
1992  
1993  =head1 POSIX CONSTANTS
1994  
1995  =over 8
1996  
1997  =item Constants
1998  
1999  _POSIX_ARG_MAX _POSIX_CHILD_MAX _POSIX_CHOWN_RESTRICTED _POSIX_JOB_CONTROL _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_NO_TRUNC _POSIX_OPEN_MAX _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SAVED_IDS _POSIX_SSIZE_MAX _POSIX_STREAM_MAX _POSIX_TZNAME_MAX _POSIX_VDISABLE _POSIX_VERSION
2000  
2001  =back
2002  
2003  =head1 SYSTEM CONFIGURATION
2004  
2005  =over 8
2006  
2007  =item Constants
2008  
2009  _SC_ARG_MAX _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION
2010  
2011  =back
2012  
2013  =head1 ERRNO
2014  
2015  =over 8
2016  
2017  =item Constants
2018  
2019  E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY EBADF
2020  EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ
2021  EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS EINTR
2022  EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK EMSGSIZE ENAMETOOLONG
2023  ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS ENODEV ENOENT ENOEXEC
2024  ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR
2025  ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM EPFNOSUPPORT EPIPE
2026  EPROCLIM EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART EROFS
2027  ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS
2028  ETXTBSY EUSERS EWOULDBLOCK EXDEV
2029  
2030  =back
2031  
2032  =head1 FCNTL
2033  
2034  =over 8
2035  
2036  =item Constants
2037  
2038  FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_OK F_RDLCK F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK O_RDONLY O_RDWR O_TRUNC O_WRONLY
2039  
2040  =back
2041  
2042  =head1 FLOAT
2043  
2044  =over 8
2045  
2046  =item Constants
2047  
2048  DBL_DIG DBL_EPSILON DBL_MANT_DIG DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP FLT_DIG FLT_EPSILON FLT_MANT_DIG FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP FLT_RADIX FLT_ROUNDS LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP
2049  
2050  =back
2051  
2052  =head1 LIMITS
2053  
2054  =over 8
2055  
2056  =item Constants
2057  
2058  ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX
2059  
2060  =back
2061  
2062  =head1 LOCALE
2063  
2064  =over 8
2065  
2066  =item Constants
2067  
2068  LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME
2069  
2070  =back
2071  
2072  =head1 MATH
2073  
2074  =over 8
2075  
2076  =item Constants
2077  
2078  HUGE_VAL
2079  
2080  =back
2081  
2082  =head1 SIGNAL
2083  
2084  =over 8
2085  
2086  =item Constants
2087  
2088  SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK SA_RESETHAND SA_RESTART
2089  SA_SIGINFO SIGABRT SIGALRM SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT
2090  SIGKILL SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN SIGTTOU
2091  SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK
2092  SIG_UNBLOCK
2093  
2094  =back
2095  
2096  =head1 STAT
2097  
2098  =over 8
2099  
2100  =item Constants
2101  
2102  S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR
2103  
2104  =item Macros
2105  
2106  S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG
2107  
2108  =back
2109  
2110  =head1 STDLIB
2111  
2112  =over 8
2113  
2114  =item Constants
2115  
2116  EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX RAND_MAX
2117  
2118  =back
2119  
2120  =head1 STDIO
2121  
2122  =over 8
2123  
2124  =item Constants
2125  
2126  BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid L_tmpname TMP_MAX
2127  
2128  =back
2129  
2130  =head1 TIME
2131  
2132  =over 8
2133  
2134  =item Constants
2135  
2136  CLK_TCK CLOCKS_PER_SEC
2137  
2138  =back
2139  
2140  =head1 UNISTD
2141  
2142  =over 8
2143  
2144  =item Constants
2145  
2146  R_OK SEEK_CUR SEEK_END SEEK_SET STDIN_FILENO STDOUT_FILENO STDERR_FILENO W_OK X_OK
2147  
2148  =back
2149  
2150  =head1 WAIT
2151  
2152  =over 8
2153  
2154  =item Constants
2155  
2156  WNOHANG WUNTRACED
2157  
2158  =over 16
2159  
2160  =item WNOHANG
2161  
2162  Do not suspend the calling process until a child process
2163  changes state but instead return immediately.
2164  
2165  =item WUNTRACED
2166  
2167  Catch stopped child processes.
2168  
2169  =back
2170  
2171  =item Macros
2172  
2173  WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG
2174  
2175  =over 16
2176  
2177  =item WIFEXITED
2178  
2179  WIFEXITED($?) returns true if the child process exited normally
2180  (C<exit()> or by falling off the end of C<main()>)
2181  
2182  =item WEXITSTATUS
2183  
2184  WEXITSTATUS($?) returns the normal exit status of the child process
2185  (only meaningful if WIFEXITED($?) is true)
2186  
2187  =item WIFSIGNALED
2188  
2189  WIFSIGNALED($?) returns true if the child process terminated because
2190  of a signal
2191  
2192  =item WTERMSIG
2193  
2194  WTERMSIG($?) returns the signal the child process terminated for
2195  (only meaningful if WIFSIGNALED($?) is true)
2196  
2197  =item WIFSTOPPED
2198  
2199  WIFSTOPPED($?) returns true if the child process is currently stopped
2200  (can happen only if you specified the WUNTRACED flag to waitpid())
2201  
2202  =item WSTOPSIG
2203  
2204  WSTOPSIG($?) returns the signal the child process was stopped for
2205  (only meaningful if WIFSTOPPED($?) is true)
2206  
2207  =back
2208  
2209  =back
2210