This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
POSIX::asctime pod: Note it always returns English
[perl5.git] / ext / POSIX / lib / POSIX.pod
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 This document gives a condensed list of the features available in the POSIX
25 module.  Consult your operating system's manpages for general information on
26 most features.  Consult L<perlfunc> for functions which are noted as being
27 identical or almost identical to Perl's builtin functions.
28
29 The first section describes POSIX functions from the 1003.1 specification.
30 The second section describes some classes for signal objects, TTY objects,
31 and other miscellaneous objects.  The remaining sections list various
32 constants and macros in an organization which roughly follows IEEE Std
33 1003.1b-1993.
34
35 =head1 CAVEATS
36
37 I<Everything is exported by default> (with a handful of exceptions).
38 This is an unfortunate backwards compatibility feature and its use is
39 B<strongly L<discouraged|perlpolicy/discouraged>>.
40 You should either prevent the exporting (by saying S<C<use POSIX ();>>,
41 as usual) and then use fully qualified names (e.g. C<POSIX::SEEK_END>),
42 or give an explicit import list.
43 If you do neither and opt for the default (as in S<C<use POSIX;>>), you
44 will import I<hundreds and hundreds> of symbols into your namespace.
45
46 A few functions are not implemented because they are C specific.  If you
47 attempt to call these, they will print a message telling you that they
48 aren't implemented, and suggest using the Perl equivalent, should one
49 exist.  For example, trying to access the C<setjmp()> call will elicit the
50 message "C<setjmp() is C-specific: use eval {} instead>".
51
52 Furthermore, some evil vendors will claim 1003.1 compliance, but in fact
53 are not so: they will not pass the PCTS (POSIX Compliance Test Suites).
54 For example, one vendor may not define C<EDEADLK>, or the semantics of the
55 errno values set by C<open(2)> might not be quite right.  Perl does not
56 attempt to verify POSIX compliance.  That means you can currently
57 successfully say "use POSIX",  and then later in your program you find
58 that your vendor has been lax and there's no usable C<ICANON> macro after
59 all.  This could be construed to be a bug.
60
61 =head1 FUNCTIONS
62
63 =over 8
64
65 =item C<_exit>
66
67 This is identical to the C function C<_exit()>.  It exits the program
68 immediately which means among other things buffered I/O is B<not> flushed.
69
70 Note that when using threads and in Linux this is B<not> a good way to
71 exit a thread because in Linux processes and threads are kind of the
72 same thing (Note: while this is the situation in early 2003 there are
73 projects under way to have threads with more POSIXly semantics in Linux).
74 If you want not to return from a thread, detach the thread.
75
76 =item C<abort>
77
78 This is identical to the C function C<abort()>.  It terminates the
79 process with a C<SIGABRT> signal unless caught by a signal handler or
80 if the handler does not return normally (it e.g.  does a C<longjmp>).
81
82 =item C<abs>
83
84 This is identical to Perl's builtin C<abs()> function, returning the absolute
85 value of its numerical argument (except that C<POSIX::abs()> must be provided
86 an explicit value (rather than relying on an implicit C<$_>):
87
88     $absolute_value = POSIX::abs(42);   # good
89
90     $absolute_value = POSIX::abs();     # throws exception
91
92 =item C<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 C<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 C<acosh>
111
112 This is identical to the C function C<acosh()>, returning the
113 hyperbolic arcus cosine of its numerical argument [C99].  See also
114 L<Math::Trig>.  Added in Perl v5.22.
115
116 =item C<alarm>
117
118 This is identical to Perl's builtin C<alarm()> function, either for arming or
119 disarming the C<SIGARLM> timer, except that C<POSIX::alarm()> must be provided
120 an explicit value (rather than relying on an implicit C<$_>):
121
122     POSIX::alarm(3)     # good
123
124     POSIX::alarm()      # throws exception
125
126 =item C<asctime>
127
128 This is identical to the C function C<asctime()>.  It returns
129 a string of the form
130
131         "Fri Jun  2 18:22:13 2000\n\0"
132
133 and it is called thusly
134
135         $asctime = asctime($sec, $min, $hour, $mday, $mon,
136                            $year, $wday, $yday, $isdst);
137
138 The C<$mon> is zero-based: January equals C<0>.  The C<$year> is
139 1900-based: 2001 equals C<101>.  C<$wday> and C<$yday> default to zero
140 (and are usually ignored anyway), and C<$isdst> defaults to -1.
141
142 Note the result is always in English.  Use C<L</strftime>> instead to
143 get a result suitable for the current locale.  That function's C<%c>
144 format yields the locale's preferred representation.
145
146 =item C<asin>
147
148 This is identical to the C function C<asin()>, returning
149 the arcus sine of its numerical argument.  See also L<Math::Trig>.
150
151 =item C<asinh>
152
153 This is identical to the C function C<asinh()>, returning the
154 hyperbolic arcus sine of its numerical argument [C99].  See also
155 L<Math::Trig>.  Added in Perl v5.22.
156
157 =item C<assert>
158
159 Unimplemented, but you can use L<perlfunc/die> and the L<Carp> module
160 to achieve similar things.
161
162 =item C<atan>
163
164 This is identical to the C function C<atan()>, returning the
165 arcus tangent of its numerical argument.  See also L<Math::Trig>.
166
167 =item C<atanh>
168
169 This is identical to the C function C<atanh()>, returning the
170 hyperbolic arcus tangent of its numerical argument [C99].  See also
171 L<Math::Trig>.  Added in Perl v5.22.
172
173 =item C<atan2>
174
175 This is identical to Perl's builtin C<atan2()> function, returning
176 the arcus tangent defined by its two numerical arguments, the I<y>
177 coordinate and the I<x> coordinate.  See also L<Math::Trig>.
178
179 =item C<atexit>
180
181 Not implemented.  C<atexit()> is C-specific: use C<END {}> instead, see L<perlmod>.
182
183 =item C<atof>
184
185 Not implemented.  C<atof()> is C-specific.  Perl converts strings to numbers transparently.
186 If you need to force a scalar to a number, add a zero to it.
187
188 =item C<atoi>
189
190 Not implemented.  C<atoi()> is C-specific.  Perl converts strings to numbers transparently.
191 If you need to force a scalar to a number, add a zero to it.
192 If you need to have just the integer part, see L<perlfunc/int>.
193
194 =item C<atol>
195
196 Not implemented.  C<atol()> is C-specific.  Perl converts strings to numbers transparently.
197 If you need to force a scalar to a number, add a zero to it.
198 If you need to have just the integer part, see L<perlfunc/int>.
199
200 =item C<bsearch>
201
202 C<bsearch()> not supplied.  For doing binary search on wordlists,
203 see L<Search::Dict>.
204
205 =item C<calloc>
206
207 Not implemented.  C<calloc()> is C-specific.  Perl does memory management transparently.
208
209 =item C<cbrt>
210
211 The cube root [C99].  Added in Perl v5.22.
212
213 =item C<ceil>
214
215 This is identical to the C function C<ceil()>, returning the smallest
216 integer value greater than or equal to the given numerical argument.
217
218 =item C<chdir>
219
220 This is identical to Perl's builtin C<chdir()> function, allowing one to
221 change the working (default) directory -- see L<perlfunc/chdir> -- with the
222 exception that C<POSIX::chdir()> must be provided an explicit value (rather
223 than relying on an implicit C<$_>):
224
225     $rv = POSIX::chdir('path/to/dir');      # good
226
227     $rv = POSIX::chdir();                   # throws exception
228
229 =item C<chmod>
230
231 This is identical to Perl's builtin C<chmod()> function, allowing
232 one to change file and directory permissions -- see L<perlfunc/chmod> -- with
233 the exception that C<POSIX::chmod()> can only change one file at a time
234 (rather than a list of files):
235
236     $c = chmod 0664, $file1, $file2;          # good
237
238     $c = POSIX::chmod 0664, $file1;           # throws exception
239
240     $c = POSIX::chmod 0664, $file1, $file2;   # throws exception
241
242 As with the built-in C<chmod()>, C<$file> may be a filename or a file
243 handle.
244
245 =item C<chown>
246
247 This is identical to Perl's builtin C<chown()> function, allowing one
248 to change file and directory owners and groups, see L<perlfunc/chown>.
249
250 =item C<clearerr>
251
252 Not implemented.  Use the method C<IO::Handle::clearerr()> instead, to reset the error
253 state (if any) and EOF state (if any) of the given stream.
254
255 =item C<clock>
256
257 This is identical to the C function C<clock()>, returning the
258 amount of spent processor time in microseconds.
259
260 =item C<close>
261
262 Close the file.  This uses file descriptors such as those obtained by calling
263 C<POSIX::open>.
264
265         $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
266         POSIX::close( $fd );
267
268 Returns C<undef> on failure.
269
270 See also L<perlfunc/close>.
271
272 =item C<closedir>
273
274 This is identical to Perl's builtin C<closedir()> function for closing
275 a directory handle, see L<perlfunc/closedir>.
276
277 =item C<cos>
278
279 This is identical to Perl's builtin C<cos()> function, for returning
280 the cosine of its numerical argument, see L<perlfunc/cos>.
281 See also L<Math::Trig>.
282
283 =item C<cosh>
284
285 This is identical to the C function C<cosh()>, for returning
286 the hyperbolic cosine of its numeric argument.  See also L<Math::Trig>.
287
288 =item C<copysign>
289
290 Returns C<x> but with the sign of C<y> [C99].  Added in Perl v5.22.
291
292  $x_with_sign_of_y = POSIX::copysign($x, $y);
293
294 See also L</signbit>.
295
296 =item C<creat>
297
298 Create a new file.  This returns a file descriptor like the ones returned by
299 C<POSIX::open>.  Use C<POSIX::close> to close the file.
300
301         $fd = POSIX::creat( "foo", 0611 );
302         POSIX::close( $fd );
303
304 See also L<perlfunc/sysopen> and its C<O_CREAT> flag.
305
306 =item C<ctermid>
307
308 Generates the path name for the controlling terminal.
309
310         $path = POSIX::ctermid();
311
312 =item C<ctime>
313
314 This is identical to the C function C<ctime()> and equivalent
315 to C<asctime(localtime(...))>, see L</asctime> and L</localtime>.
316
317 =item C<cuserid> [POSIX.1-1988]
318
319 Get the login name of the owner of the current process.
320
321         $name = POSIX::cuserid();
322
323 Note: this function has not been specified by POSIX since 1990 and is included
324 only for backwards compatibility. New code should use L<C<getlogin()>|perlfunc/getlogin> instead.
325
326 =item C<difftime>
327
328 This is identical to the C function C<difftime()>, for returning
329 the time difference (in seconds) between two times (as returned
330 by C<time()>), see L</time>.
331
332 =item C<div>
333
334 Not implemented.  C<div()> is C-specific, use L<perlfunc/int> on the usual C</> division and
335 the modulus C<%>.
336
337 =item C<dup>
338
339 This is similar to the C function C<dup()>, for duplicating a file
340 descriptor.
341
342 This uses file descriptors such as those obtained by calling
343 C<POSIX::open>.
344
345 Returns C<undef> on failure.
346
347 =item C<dup2>
348
349 This is similar to the C function C<dup2()>, for duplicating a file
350 descriptor to an another known file descriptor.
351
352 This uses file descriptors such as those obtained by calling
353 C<POSIX::open>.
354
355 Returns C<undef> on failure.
356
357 =item C<erf>
358
359 The error function [C99].  Added in Perl v5.22.
360
361 =item C<erfc>
362
363 The complementary error function [C99].  Added in Perl v5.22.
364
365 =item C<errno>
366
367 Returns the value of errno.
368
369         $errno = POSIX::errno();
370
371 This identical to the numerical values of the C<$!>, see L<perlvar/$ERRNO>.
372
373 =item C<execl>
374
375 Not implemented.  C<execl()> is C-specific, see L<perlfunc/exec>.
376
377 =item C<execle>
378
379 Not implemented.  C<execle()> is C-specific, see L<perlfunc/exec>.
380
381 =item C<execlp>
382
383 Not implemented.  C<execlp()> is C-specific, see L<perlfunc/exec>.
384
385 =item C<execv>
386
387 Not implemented.  C<execv()> is C-specific, see L<perlfunc/exec>.
388
389 =item C<execve>
390
391 Not implemented.  C<execve()> is C-specific, see L<perlfunc/exec>.
392
393 =item C<execvp>
394
395 Not implemented.  C<execvp()> is C-specific, see L<perlfunc/exec>.
396
397 =item C<exit>
398
399 This is identical to Perl's builtin C<exit()> function for exiting the
400 program, see L<perlfunc/exit>.
401
402 =item C<exp>
403
404 This is identical to Perl's builtin C<exp()> function for
405 returning the exponent (I<e>-based) of the numerical argument,
406 see L<perlfunc/exp>.
407
408 =item C<expm1>
409
410 Equivalent to C<exp(x) - 1>, but more precise for small argument values [C99].
411 Added in Perl v5.22.
412
413 See also L</log1p>.
414
415 =item C<fabs>
416
417 This is identical to Perl's builtin C<abs()> function for returning
418 the absolute value of the numerical argument, see L<perlfunc/abs>.
419
420 =item C<fclose>
421
422 Not implemented.  Use method C<IO::Handle::close()> instead, or see L<perlfunc/close>.
423
424 =item C<fcntl>
425
426 This is identical to Perl's builtin C<fcntl()> function,
427 see L<perlfunc/fcntl>.
428
429 =item C<fdopen>
430
431 Not implemented.  Use method C<IO::Handle::new_from_fd()> instead, or see L<perlfunc/open>.
432
433 =item C<feof>
434
435 Not implemented.  Use method C<IO::Handle::eof()> instead, or see L<perlfunc/eof>.
436
437 =item C<ferror>
438
439 Not implemented.  Use method C<IO::Handle::error()> instead.
440
441 =item C<fflush>
442
443 Not implemented.  Use method C<IO::Handle::flush()> instead.
444 See also C<L<perlvar/$OUTPUT_AUTOFLUSH>>.
445
446 =item C<fgetc>
447
448 Not implemented.  Use method C<IO::Handle::getc()> instead, or see L<perlfunc/read>.
449
450 =item C<fgetpos>
451
452 Not implemented.  Use method C<IO::Seekable::getpos()> instead, or see L<perlfunc/seek>.
453
454 =item C<fgets>
455
456 Not implemented.  Use method C<IO::Handle::gets()> instead.  Similar to E<lt>E<gt>, also known
457 as L<perlfunc/readline>.
458
459 =item C<fileno>
460
461 Not implemented.  Use method C<IO::Handle::fileno()> instead, or see L<perlfunc/fileno>.
462
463 =item C<floor>
464
465 This is identical to the C function C<floor()>, returning the largest
466 integer value less than or equal to the numerical argument.
467
468 =item C<fdim>
469
470 "Positive difference", S<C<x - y>> if S<C<x E<gt> y>>, zero otherwise [C99].
471 Added in Perl v5.22.
472
473 =item C<fegetround>
474
475 Returns the current floating point rounding mode, one of
476
477   FE_TONEAREST FE_TOWARDZERO FE_UPWARD FE_DOWNWARD
478
479 C<FE_TONEAREST> is like L</round>, C<FE_TOWARDZERO> is like L</trunc> [C99].
480 Added in Perl v5.22.
481
482 =item C<fesetround>
483
484 Sets the floating point rounding mode, see L</fegetround> [C99].  Added in
485 Perl v5.22.
486
487 =item C<fma>
488
489 "Fused multiply-add", S<C<x * y + z>>, possibly faster (and less lossy)
490 than the explicit two operations [C99].  Added in Perl v5.22.
491
492  my $fused = POSIX::fma($x, $y, $z);
493
494 =item C<fmax>
495
496 Maximum of C<x> and C<y>, except when either is C<NaN>, returns the other [C99].
497 Added in Perl v5.22.
498
499  my $min = POSIX::fmax($x, $y);
500
501 =item C<fmin>
502
503 Minimum of C<x> and C<y>, except when either is C<NaN>, returns the other [C99].
504 Added in Perl v5.22.
505
506  my $min = POSIX::fmin($x, $y);
507
508 =item C<fmod>
509
510 This is identical to the C function C<fmod()>.
511
512         $r = fmod($x, $y);
513
514 It returns the remainder S<C<$r = $x - $n*$y>>, where S<C<$n = trunc($x/$y)>>.
515 The C<$r> has the same sign as C<$x> and magnitude (absolute value)
516 less than the magnitude of C<$y>.
517
518 =item C<fopen>
519
520 Not implemented.  Use method C<IO::File::open()> instead, or see L<perlfunc/open>.
521
522 =item C<fork>
523
524 This is identical to Perl's builtin C<fork()> function
525 for duplicating the current process, see L<perlfunc/fork>
526 and L<perlfork> if you are in Windows.
527
528 =item C<fpathconf>
529
530 Retrieves the value of a configurable limit on a file or directory.  This
531 uses file descriptors such as those obtained by calling C<POSIX::open>.
532
533 The following will determine the maximum length of the longest allowable
534 pathname on the filesystem which holds F</var/foo>.
535
536         $fd = POSIX::open( "/var/foo", &POSIX::O_RDONLY );
537         $path_max = POSIX::fpathconf($fd, &POSIX::_PC_PATH_MAX);
538
539 Returns C<undef> on failure.
540
541 =item C<fpclassify>
542
543 Returns one of
544
545   FP_NORMAL FP_ZERO FP_SUBNORMAL FP_INFINITE FP_NAN
546
547 telling the class of the argument [C99].  C<FP_INFINITE> is positive
548 or negative infinity, C<FP_NAN> is not-a-number.  C<FP_SUBNORMAL>
549 means subnormal numbers (also known as denormals), very small numbers
550 with low precision. C<FP_ZERO> is zero.  C<FP_NORMAL> is all the rest.
551 Added in Perl v5.22.
552
553 =item C<fprintf>
554
555 Not implemented.  C<fprintf()> is C-specific, see L<perlfunc/printf> instead.
556
557 =item C<fputc>
558
559 Not implemented.  C<fputc()> is C-specific, see L<perlfunc/print> instead.
560
561 =item C<fputs>
562
563 Not implemented.  C<fputs()> is C-specific, see L<perlfunc/print> instead.
564
565 =item C<fread>
566
567 Not implemented.  C<fread()> is C-specific, see L<perlfunc/read> instead.
568
569 =item C<free>
570
571 Not implemented.  C<free()> is C-specific.  Perl does memory management transparently.
572
573 =item C<freopen>
574
575 Not implemented.  C<freopen()> is C-specific, see L<perlfunc/open> instead.
576
577 =item C<frexp>
578
579 Return the mantissa and exponent of a floating-point number.
580
581         ($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
582
583 =item C<fscanf>
584
585 Not implemented.  C<fscanf()> is C-specific, use E<lt>E<gt> and regular expressions instead.
586
587 =item C<fseek>
588
589 Not implemented.  Use method C<IO::Seekable::seek()> instead, or see L<perlfunc/seek>.
590
591 =item C<fsetpos>
592
593 Not implemented.  Use method C<IO::Seekable::setpos()> instead, or seek L<perlfunc/seek>.
594
595 =item C<fstat>
596
597 Get file status.  This uses file descriptors such as those obtained by
598 calling C<POSIX::open>.  The data returned is identical to the data from
599 Perl's builtin C<stat> function.
600
601         $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
602         @stats = POSIX::fstat( $fd );
603
604 =item C<fsync>
605
606 Not implemented.  Use method C<IO::Handle::sync()> instead.
607
608 =item C<ftell>
609
610 Not implemented.  Use method C<IO::Seekable::tell()> instead, or see L<perlfunc/tell>.
611
612 =item C<fwrite>
613
614 Not implemented.  C<fwrite()> is C-specific, see L<perlfunc/print> instead.
615
616 =item C<getc>
617
618 This is identical to Perl's builtin C<getc()> function,
619 see L<perlfunc/getc>.
620
621 =item C<getchar>
622
623 Returns one character from STDIN.  Identical to Perl's C<getc()>,
624 see L<perlfunc/getc>.
625
626 =item C<getcwd>
627
628 Returns the name of the current working directory.
629 See also L<Cwd>.
630
631 =item C<getegid>
632
633 Returns the effective group identifier.  Similar to Perl' s builtin
634 variable C<$(>, see L<perlvar/$EGID>.
635
636 =item C<getenv>
637
638 Returns the value of the specified environment variable.
639 The same information is available through the C<%ENV> array.
640
641 =item C<geteuid>
642
643 Returns the effective user identifier.  Identical to Perl's builtin C<$E<gt>>
644 variable, see L<perlvar/$EUID>.
645
646 =item C<getgid>
647
648 Returns the user's real group identifier.  Similar to Perl's builtin
649 variable C<$)>, see L<perlvar/$GID>.
650
651 =item C<getgrgid>
652
653 This is identical to Perl's builtin C<getgrgid()> function for
654 returning group entries by group identifiers, see
655 L<perlfunc/getgrgid>.
656
657 =item C<getgrnam>
658
659 This is identical to Perl's builtin C<getgrnam()> function for
660 returning group entries by group names, see L<perlfunc/getgrnam>.
661
662 =item C<getgroups>
663
664 Returns the ids of the user's supplementary groups.  Similar to Perl's
665 builtin variable C<$)>, see L<perlvar/$GID>.
666
667 =item C<getlogin>
668
669 This is identical to Perl's builtin C<getlogin()> function for
670 returning the user name associated with the current session, see
671 L<perlfunc/getlogin>.
672
673 =item C<getpayload>
674
675         use POSIX ':nan_payload';
676         getpayload($var)
677
678 Returns the C<NaN> payload.  Added in Perl v5.24.
679
680 Note the API instability warning in L</setpayload>.
681
682 See L</nan> for more discussion about C<NaN>.
683
684 =item C<getpgrp>
685
686 This is identical to Perl's builtin C<getpgrp()> function for
687 returning the process group identifier of the current process, see
688 L<perlfunc/getpgrp>.
689
690 =item C<getpid>
691
692 Returns the process identifier.  Identical to Perl's builtin
693 variable C<$$>, see L<perlvar/$PID>.
694
695 =item C<getppid>
696
697 This is identical to Perl's builtin C<getppid()> function for
698 returning the process identifier of the parent process of the current
699 process , see L<perlfunc/getppid>.
700
701 =item C<getpwnam>
702
703 This is identical to Perl's builtin C<getpwnam()> function for
704 returning user entries by user names, see L<perlfunc/getpwnam>.
705
706 =item C<getpwuid>
707
708 This is identical to Perl's builtin C<getpwuid()> function for
709 returning user entries by user identifiers, see L<perlfunc/getpwuid>.
710
711 =item C<gets>
712
713 Returns one line from C<STDIN>, similar to E<lt>E<gt>, also known
714 as the C<readline()> function, see L<perlfunc/readline>.
715
716 B<NOTE>: if you have C programs that still use C<gets()>, be very
717 afraid.  The C<gets()> function is a source of endless grief because
718 it has no buffer overrun checks.  It should B<never> be used.  The
719 C<fgets()> function should be preferred instead.
720
721 =item C<getuid>
722
723 Returns the user's identifier.  Identical to Perl's builtin C<$E<lt>> variable,
724 see L<perlvar/$UID>.
725
726 =item C<gmtime>
727
728 This is identical to Perl's builtin C<gmtime()> function for
729 converting seconds since the epoch to a date in Greenwich Mean Time,
730 see L<perlfunc/gmtime>.
731
732 =item C<hypot>
733
734 Equivalent to C<S<sqrt(x * x + y * y)>> except more stable on very large
735 or very small arguments [C99].  Added in Perl v5.22.
736
737 =item C<ilogb>
738
739 Integer binary logarithm [C99].  Added in Perl v5.22.
740
741 For example C<ilogb(20)> is 4, as an integer.
742
743 See also L</logb>.
744
745 =item C<Inf>
746
747 The infinity as a constant:
748
749    use POSIX qw(Inf);
750    my $pos_inf = +Inf;  # Or just Inf.
751    my $neg_inf = -Inf;
752
753 See also L</isinf>, and L</fpclassify>.
754
755 =item C<isalnum>
756
757 This function has been removed as of Perl v5.24.  It was very similar to
758 matching against S<C<qr/ ^ [[:alnum:]]+ $ /x>>, which you should convert
759 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
760
761 =item C<isalpha>
762
763 This function has been removed as of Perl v5.24.  It was very similar to
764 matching against S<C<qr/ ^ [[:alpha:]]+ $ /x>>, which you should convert
765 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
766
767 =item C<isatty>
768
769 Returns a boolean indicating whether the specified filehandle is connected
770 to a tty.  Similar to the C<-t> operator, see L<perlfunc/-X>.
771
772 =item C<iscntrl>
773
774 This function has been removed as of Perl v5.24.  It was very similar to
775 matching against S<C<qr/ ^ [[:cntrl:]]+ $ /x>>, which you should convert
776 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
777
778 =item C<isdigit>
779
780 This function has been removed as of Perl v5.24.  It was very similar to
781 matching against S<C<qr/ ^ [[:digit:]]+ $ /x>>, which you should convert
782 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
783
784 =item C<isfinite>
785
786 Returns true if the argument is a finite number (that is, not an
787 infinity, or the not-a-number) [C99].  Added in Perl v5.22.
788
789 See also L</isinf>, L</isnan>, and L</fpclassify>.
790
791 =item C<isgraph>
792
793 This function has been removed as of Perl v5.24.  It was very similar to
794 matching against S<C<qr/ ^ [[:graph:]]+ $ /x>>, which you should convert
795 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
796
797 =item C<isgreater>
798
799 (Also C<isgreaterequal>, C<isless>, C<islessequal>, C<islessgreater>,
800 C<isunordered>)
801
802 Floating point comparisons which handle the C<NaN> [C99].  Added in Perl
803 v5.22.
804
805 =item C<isinf>
806
807 Returns true if the argument is an infinity (positive or negative) [C99].
808 Added in Perl v5.22.
809
810 See also L</Inf>, L</isnan>, L</isfinite>, and L</fpclassify>.
811
812 =item C<islower>
813
814 This function has been removed as of Perl v5.24.  It was very similar to
815 matching against S<C<qr/ ^ [[:lower:]]+ $ /x>>, which you should convert
816 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
817
818 =item C<isnan>
819
820 Returns true if the argument is C<NaN> (not-a-number) [C99].  Added in
821 Perl v5.22.
822
823 Note that you cannot test for "C<NaN>-ness" with
824
825    $x == $x
826
827 since the C<NaN> is not equivalent to anything, B<including itself>.
828
829 See also L</nan>, L</NaN>, L</isinf>, and L</fpclassify>.
830
831 =item C<isnormal>
832
833 Returns true if the argument is normal (that is, not a subnormal/denormal,
834 and not an infinity, or a not-a-number) [C99].  Added in Perl v5.22.
835
836 See also L</isfinite>, and L</fpclassify>.
837
838 =item C<isprint>
839
840 This function has been removed as of Perl v5.24.  It was very similar to
841 matching against S<C<qr/ ^ [[:print:]]+ $ /x>>, which you should convert
842 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
843
844 =item C<ispunct>
845
846 This function has been removed as of Perl v5.24.  It was very similar to
847 matching against S<C<qr/ ^ [[:punct:]]+ $ /x>>, which you should convert
848 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
849
850 =item C<issignaling>
851
852         use POSIX ':nan_payload';
853         issignaling($var, $payload)
854
855 Return true if the argument is a I<signaling> NaN.  Added in Perl v5.24.
856
857 Note the API instability warning in L</setpayload>.
858
859 See L</nan> for more discussion about C<NaN>.
860
861 =item C<isspace>
862
863 This function has been removed as of Perl v5.24.  It was very similar to
864 matching against S<C<qr/ ^ [[:space:]]+ $ /x>>, which you should convert
865 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
866
867 =item C<isupper>
868
869 This function has been removed as of Perl v5.24.  It was very similar to
870 matching against S<C<qr/ ^ [[:upper:]]+ $ /x>>, which you should convert
871 to use instead.  See L<perlrecharclass/POSIX Character Classes>.
872
873 =item C<isxdigit>
874
875 This function has been removed as of Perl v5.24.  It was very similar to
876 matching against S<C<qr/ ^ [[:xdigit:]]+ $ /x>>, which you should
877 convert to use instead.  See L<perlrecharclass/POSIX Character Classes>.
878
879 =item C<j0>
880
881 =item C<j1>
882
883 =item C<jn>
884
885 =item C<y0>
886
887 =item C<y1>
888
889 =item C<yn>
890
891 The Bessel function of the first kind of the order zero.
892
893 =item C<kill>
894
895 This is identical to Perl's builtin C<kill()> function for sending
896 signals to processes (often to terminate them), see L<perlfunc/kill>.
897
898 =item C<labs>
899
900 Not implemented.  (For returning absolute values of long integers.)
901 C<labs()> is C-specific, see L<perlfunc/abs> instead.
902
903 =item C<lchown>
904
905 This is identical to the C function, except the order of arguments is
906 consistent with Perl's builtin C<chown()> with the added restriction
907 of only one path, not a list of paths.  Does the same thing as the
908 C<chown()> function but changes the owner of a symbolic link instead
909 of the file the symbolic link points to.
910
911  POSIX::lchown($uid, $gid, $file_path);
912
913 =item C<ldexp>
914
915 This is identical to the C function C<ldexp()>
916 for multiplying floating point numbers with powers of two.
917
918         $x_quadrupled = POSIX::ldexp($x, 2);
919
920 =item C<ldiv>
921
922 Not implemented.  (For computing dividends of long integers.)
923 C<ldiv()> is C-specific, use C</> and C<int()> instead.
924
925 =item C<lgamma>
926
927 The logarithm of the Gamma function [C99].  Added in Perl v5.22.
928
929 See also L</tgamma>.
930
931 =item C<log1p>
932
933 Equivalent to S<C<log(1 + x)>>, but more stable results for small argument
934 values [C99].  Added in Perl v5.22.
935
936 =item C<log2>
937
938 Logarithm base two [C99].  Added in Perl v5.22.
939
940 See also L</expm1>.
941
942 =item C<logb>
943
944 Integer binary logarithm [C99].  Added in Perl v5.22.
945
946 For example C<logb(20)> is 4, as a floating point number.
947
948 See also L</ilogb>.
949
950 =item C<link>
951
952 This is identical to Perl's builtin C<link()> function
953 for creating hard links into files, see L<perlfunc/link>.
954
955 =item C<localeconv>
956
957 Get numeric formatting information.  Returns a reference to a hash
958 containing the formatting values of the locale that currently underlies
959 the program, regardless of whether or not it is called from within the
960 scope of a S<C<use locale>>.  Users of this function should also read
961 L<perllocale>, which provides a comprehensive discussion of Perl locale
962 handling, including
963 L<a section devoted to this function|perllocale/The localeconv function>.
964 Prior to Perl 5.28, or when operating in a non thread-safe environment,
965 it should not be used in a threaded application unless it's certain that
966 the underlying locale is C or POSIX.  This is because it otherwise
967 changes the locale, which globally affects all threads simultaneously.
968 Windows platforms starting with Visual Studio 2005 are mostly
969 thread-safe, but use of this function in those prior to Visual Studio
970 2015 can interfere with a thread that has called
971 L<perlapi/switch_to_global_locale>.
972
973 Here is how to query the database for the B<de> (Deutsch or German) locale.
974
975         my $loc = POSIX::setlocale( &POSIX::LC_ALL, "de" );
976         print "Locale: \"$loc\"\n";
977         my $lconv = POSIX::localeconv();
978         foreach my $property (qw(
979                 decimal_point
980                 thousands_sep
981                 grouping
982                 int_curr_symbol
983                 currency_symbol
984                 mon_decimal_point
985                 mon_thousands_sep
986                 mon_grouping
987                 positive_sign
988                 negative_sign
989                 int_frac_digits
990                 frac_digits
991                 p_cs_precedes
992                 p_sep_by_space
993                 n_cs_precedes
994                 n_sep_by_space
995                 p_sign_posn
996                 n_sign_posn
997                 int_p_cs_precedes
998                 int_p_sep_by_space
999                 int_n_cs_precedes
1000                 int_n_sep_by_space
1001                 int_p_sign_posn
1002                 int_n_sign_posn
1003         ))
1004         {
1005                 printf qq(%s: "%s",\n),
1006                         $property, $lconv->{$property};
1007         }
1008
1009 The members whose names begin with C<int_p_> and C<int_n_> were added by
1010 POSIX.1-2008 and are only available on systems that support them.
1011
1012 =item C<localtime>
1013
1014 This is identical to Perl's builtin C<localtime()> function for
1015 converting seconds since the epoch to a date see L<perlfunc/localtime> except
1016 that C<POSIX::localtime()> must be provided an explicit value (rather than
1017 relying on an implicit C<$_>):
1018
1019     @localtime = POSIX::localtime(time);    # good
1020
1021     @localtime = localtime();               # good
1022
1023     @localtime = POSIX::localtime();        # throws exception
1024
1025 =item C<log>
1026
1027 This is identical to Perl's builtin C<log()> function,
1028 returning the natural (I<e>-based) logarithm of the numerical argument,
1029 see L<perlfunc/log>.
1030
1031 =item C<log10>
1032
1033 This is identical to the C function C<log10()>,
1034 returning the 10-base logarithm of the numerical argument.
1035 You can also use
1036
1037     sub log10 { log($_[0]) / log(10) }
1038
1039 or
1040
1041     sub log10 { log($_[0]) / 2.30258509299405 }
1042
1043 or
1044
1045     sub log10 { log($_[0]) * 0.434294481903252 }
1046
1047 =item C<longjmp>
1048
1049 Not implemented.  C<longjmp()> is C-specific: use L<perlfunc/die> instead.
1050
1051 =item C<lseek>
1052
1053 Move the file's read/write position.  This uses file descriptors such as
1054 those obtained by calling C<POSIX::open>.
1055
1056         $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
1057         $off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
1058
1059 Returns C<undef> on failure.
1060
1061 =item C<lrint>
1062
1063 Depending on the current floating point rounding mode, rounds the
1064 argument either toward nearest (like L</round>), toward zero (like
1065 L</trunc>), downward (toward negative infinity), or upward (toward
1066 positive infinity) [C99].  Added in Perl v5.22.
1067
1068 For the rounding mode, see L</fegetround>.
1069
1070 =item C<lround>
1071
1072 Like L</round>, but as integer, as opposed to floating point [C99].  Added
1073 in Perl v5.22.
1074
1075 See also L</ceil>, L</floor>, L</trunc>.
1076
1077 Owing to an oversight, this is not currently exported by default, or as part of
1078 the C<:math_h_c99> export tag; importing it must therefore be done by explicit
1079 name.
1080
1081 =item C<malloc>
1082
1083 Not implemented.  C<malloc()> is C-specific.  Perl does memory management transparently.
1084
1085 =item C<mblen>
1086
1087 This is the same as the C function C<mblen()> on unthreaded perls.  On
1088 threaded perls, it transparently (almost) substitutes the more
1089 thread-safe L<C<mbrlen>(3)>, if available, instead of C<mblen>.
1090
1091 Core Perl does not have any support for wide and multibyte locales,
1092 except Unicode UTF-8 locales.  This function, in conjunction with
1093 L</mbtowc> and L</wctomb> may be used to roll your own decoding/encoding
1094 of other types of multi-byte locales.
1095
1096 Use C<undef> as the first parameter to this function to get the effect
1097 of passing NULL as the first parameter to C<mblen>.  This resets any
1098 shift state to its initial value.  The return value is undefined if
1099 C<mbrlen> was substituted, so you should never rely on it.
1100
1101 When the first parameter is a scalar containing a value that either is a
1102 PV string or can be forced into one, the return value is the number of
1103 bytes occupied by the first character of that string; or 0 if that first
1104 character is the wide NUL character; or negative if there is an error.
1105 This is based on the locale that currently underlies the program,
1106 regardless of whether or not the function is called from Perl code that
1107 is within the scope of S<C<use locale>>.  Perl makes no attempt at
1108 hiding from your code any differences in the C<errno> setting between
1109 C<mblen> and C<mbrlen>.  It does set C<errno> to 0 before calling them.
1110
1111 The optional second parameter is ignored if it is larger than the
1112 actual length of the first parameter string.
1113
1114 =item C<mbtowc>
1115
1116 This is the same as the C function C<mbtowc()> on unthreaded perls.  On
1117 threaded perls, it transparently (almost) substitutes the more
1118 thread-safe L<C<mbrtowc>(3)>, if available, instead of C<mbtowc>.
1119
1120 Core Perl does not have any support for wide and multibyte locales,
1121 except Unicode UTF-8 locales.  This function, in conjunction with
1122 L</mblen> and L</wctomb> may be used to roll your own decoding/encoding
1123 of other types of multi-byte locales.
1124
1125 The first parameter is a scalar into which, upon success, the wide
1126 character represented by the multi-byte string contained in the second
1127 parameter is stored.  The optional third parameter is ignored if it is
1128 larger than the actual length of the second parameter string.
1129
1130 Use C<undef> as the second parameter to this function to get the effect
1131 of passing NULL as the second parameter to C<mbtowc>.  This resets any
1132 shift state to its initial value.  The return value is undefined if
1133 C<mbrtowc> was substituted, so you should never rely on it.
1134
1135 When the second parameter is a scalar containing a value that either is
1136 a PV string or can be forced into one, the return value is the number of
1137 bytes occupied by the first character of that string; or 0 if that first
1138 character is the wide NUL character; or negative if there is an error.
1139 This is based on the locale that currently underlies the program,
1140 regardless of whether or not the function is called from Perl code that
1141 is within the scope of S<C<use locale>>.  Perl makes no attempt at
1142 hiding from your code any differences in the C<errno> setting between
1143 C<mbtowc> and C<mbrtowc>.  It does set C<errno> to 0 before calling
1144 them.
1145
1146 =item C<memchr>
1147
1148 Not implemented.  C<memchr()> is C-specific, see L<perlfunc/index> instead.
1149
1150 =item C<memcmp>
1151
1152 Not implemented.  C<memcmp()> is C-specific, use C<eq> instead, see L<perlop>.
1153
1154 =item C<memcpy>
1155
1156 Not implemented.  C<memcpy()> is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
1157
1158 =item C<memmove>
1159
1160 Not implemented.  C<memmove()> is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
1161
1162 =item C<memset>
1163
1164 Not implemented.  C<memset()> is C-specific, use C<x> instead, see L<perlop>.
1165
1166 =item C<mkdir>
1167
1168 This is identical to Perl's builtin C<mkdir()> function
1169 for creating directories, see L<perlfunc/mkdir>.
1170
1171 =item C<mkfifo>
1172
1173 This is similar to the C function C<mkfifo()> for creating
1174 FIFO special files.
1175
1176         if (mkfifo($path, $mode)) { ....
1177
1178 Returns C<undef> on failure.  The C<$mode> is similar to the
1179 mode of C<mkdir()>, see L<perlfunc/mkdir>, though for C<mkfifo>
1180 you B<must> specify the C<$mode>.
1181
1182 =item C<mktime>
1183
1184 Convert date/time info to a calendar time.
1185
1186 Synopsis:
1187
1188         mktime(sec, min, hour, mday, mon, year, wday = 0,
1189                yday = 0, isdst = -1)
1190
1191 The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero,
1192 I<i.e.>, January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1.  The
1193 year (C<year>) is given in years since 1900; I<i.e.>, the year 1995 is 95; the
1194 year 2001 is 101.  Consult your system's C<mktime()> manpage for details
1195 about these and the other arguments.
1196
1197 Calendar time for December 12, 1995, at 10:30 am.
1198
1199         $time_t = POSIX::mktime( 0, 30, 10, 12, 11, 95 );
1200         print "Date = ", POSIX::ctime($time_t);
1201
1202 Returns C<undef> on failure.
1203
1204 =item C<modf>
1205
1206 Return the integral and fractional parts of a floating-point number.
1207
1208         ($fractional, $integral) = POSIX::modf( 3.14 );
1209
1210 See also L</round>.
1211
1212 =item C<NaN>
1213
1214 The not-a-number as a constant:
1215
1216    use POSIX qw(NaN);
1217    my $nan = NaN;
1218
1219 See also L</nan>, C</isnan>, and L</fpclassify>.
1220
1221 =item C<nan>
1222
1223    my $nan = nan();
1224
1225 Returns C<NaN>, not-a-number [C99].  Added in Perl v5.22.
1226
1227 The returned NaN is always a I<quiet> NaN, as opposed to I<signaling>.
1228
1229 With an argument, can be used to generate a NaN with I<payload>.
1230 The argument is first interpreted as a floating point number,
1231 but then any fractional parts are truncated (towards zero),
1232 and the value is interpreted as an unsigned integer.
1233 The bits of this integer are stored in the unused bits of the NaN.
1234
1235 The result has a dual nature: it is a NaN, but it also carries
1236 the integer inside it.  The integer can be retrieved with L</getpayload>.
1237 Note, though, that the payload is not propagated, not even on copies,
1238 and definitely not in arithmetic operations.
1239
1240 How many bits fit in the NaN depends on what kind of floating points
1241 are being used, but on the most common platforms (64-bit IEEE 754,
1242 or the x86 80-bit long doubles) there are 51 and 61 bits available,
1243 respectively.  (There would be 52 and 62, but the quiet/signaling
1244 bit of NaNs takes away one.)  However, because of the floating-point-to-
1245 integer-and-back conversions, please test carefully whether you get back
1246 what you put in.  If your integers are only 32 bits wide, you probably
1247 should not rely on more than 32 bits of payload.
1248
1249 Whether a "signaling" NaN is in any way different from a "quiet" NaN,
1250 depends on the platform.  Also note that the payload of the default
1251 NaN (no argument to nan()) is not necessarily zero, use C<setpayload>
1252 to explicitly set the payload.  On some platforms like the 32-bit x86,
1253 (unless using the 80-bit long doubles) the signaling bit is not supported
1254 at all.
1255
1256 See also L</isnan>, L</NaN>, L</setpayload> and L</issignaling>.
1257
1258 =item C<nearbyint>
1259
1260 Returns the nearest integer to the argument, according to the current
1261 rounding mode (see L</fegetround>) [C99].  Added in Perl v5.22.
1262
1263 =item C<nextafter>
1264
1265 Returns the next representable floating point number after C<x> in the
1266 direction of C<y> [C99].  Added in Perl v5.22.
1267
1268  my $nextafter = POSIX::nextafter($x, $y);
1269
1270 Like L</nexttoward>, but potentially less accurate.
1271
1272 =item C<nexttoward>
1273
1274 Returns the next representable floating point number after C<x> in the
1275 direction of C<y> [C99].  Added in Perl v5.22.
1276
1277  my $nexttoward = POSIX::nexttoward($x, $y);
1278
1279 Like L</nextafter>, but potentially more accurate.
1280
1281 =item C<nice>
1282
1283 This is similar to the C function C<nice()>, for changing
1284 the scheduling preference of the current process.  Positive
1285 arguments mean a more polite process, negative values a more
1286 needy process.  Normal (non-root) user processes can only change towards
1287 being more polite.
1288
1289 Returns C<undef> on failure.
1290
1291 =item C<offsetof>
1292
1293 Not implemented.  C<offsetof()> is C-specific, you probably want to see L<perlfunc/pack> instead.
1294
1295 =item C<open>
1296
1297 Open a file for reading for writing.  This returns file descriptors, not
1298 Perl filehandles.  Use C<POSIX::close> to close the file.
1299
1300 Open a file read-only with mode 0666.
1301
1302         $fd = POSIX::open( "foo" );
1303
1304 Open a file for read and write.
1305
1306         $fd = POSIX::open( "foo", &POSIX::O_RDWR );
1307
1308 Open a file for write, with truncation.
1309
1310         $fd = POSIX::open(
1311                 "foo", &POSIX::O_WRONLY | &POSIX::O_TRUNC
1312         );
1313
1314 Create a new file with mode 0640.  Set up the file for writing.
1315
1316         $fd = POSIX::open(
1317                 "foo", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640
1318         );
1319
1320 Returns C<undef> on failure.
1321
1322 See also L<perlfunc/sysopen>.
1323
1324 =item C<opendir>
1325
1326 Open a directory for reading.
1327
1328         $dir = POSIX::opendir( "/var" );
1329         @files = POSIX::readdir( $dir );
1330         POSIX::closedir( $dir );
1331
1332 Returns C<undef> on failure.
1333
1334 =item C<pathconf>
1335
1336 Retrieves the value of a configurable limit on a file or directory.
1337
1338 The following will determine the maximum length of the longest allowable
1339 pathname on the filesystem which holds C</var>.
1340
1341         $path_max = POSIX::pathconf( "/var",
1342                                       &POSIX::_PC_PATH_MAX );
1343
1344 Returns C<undef> on failure.
1345
1346 =item C<pause>
1347
1348 This is similar to the C function C<pause()>, which suspends
1349 the execution of the current process until a signal is received.
1350
1351 Returns C<undef> on failure.
1352
1353 =item C<perror>
1354
1355 This is identical to the C function C<perror()>, which outputs to the
1356 standard error stream the specified message followed by C<": "> and the
1357 current error string.  Use the C<warn()> function and the C<$!>
1358 variable instead, see L<perlfunc/warn> and L<perlvar/$ERRNO>.
1359
1360 =item C<pipe>
1361
1362 Create an interprocess channel.  This returns file descriptors like those
1363 returned by C<POSIX::open>.
1364
1365         my ($read, $write) = POSIX::pipe();
1366         POSIX::write( $write, "hello", 5 );
1367         POSIX::read( $read, $buf, 5 );
1368
1369 See also L<perlfunc/pipe>.
1370
1371 =item C<pow>
1372
1373 Computes C<$x> raised to the power C<$exponent>.
1374
1375         $ret = POSIX::pow( $x, $exponent );
1376
1377 You can also use the C<**> operator, see L<perlop>.
1378
1379 =item C<printf>
1380
1381 Formats and prints the specified arguments to C<STDOUT>.
1382 See also L<perlfunc/printf>.
1383
1384 =item C<putc>
1385
1386 Not implemented.  C<putc()> is C-specific, see L<perlfunc/print> instead.
1387
1388 =item C<putchar>
1389
1390 Not implemented.  C<putchar()> is C-specific, see L<perlfunc/print> instead.
1391
1392 =item C<puts>
1393
1394 Not implemented.  C<puts()> is C-specific, see L<perlfunc/print> instead.
1395
1396 =item C<qsort>
1397
1398 Not implemented.  C<qsort()> is C-specific, see L<perlfunc/sort> instead.
1399
1400 =item C<raise>
1401
1402 Sends the specified signal to the current process.
1403 See also L<perlfunc/kill> and the C<$$> in L<perlvar/$PID>.
1404
1405 =item C<rand>
1406
1407 Not implemented.  C<rand()> is non-portable, see L<perlfunc/rand> instead.
1408
1409 =item C<read>
1410
1411 Read from a file.  This uses file descriptors such as those obtained by
1412 calling C<POSIX::open>.  If the buffer C<$buf> is not large enough for the
1413 read then Perl will extend it to make room for the request.
1414
1415         $fd = POSIX::open( "foo", &POSIX::O_RDONLY );
1416         $bytes = POSIX::read( $fd, $buf, 3 );
1417
1418 Returns C<undef> on failure.
1419
1420 See also L<perlfunc/sysread>.
1421
1422 =item C<readdir>
1423
1424 This is identical to Perl's builtin C<readdir()> function
1425 for reading directory entries, see L<perlfunc/readdir>.
1426
1427 =item C<realloc>
1428
1429 Not implemented.  C<realloc()> is C-specific.  Perl does memory management transparently.
1430
1431 =item C<remainder>
1432
1433 Given C<x> and C<y>, returns the value S<C<x - n*y>>, where C<n> is the integer
1434 closest to C<x>/C<y> [C99].  Added in Perl v5.22.
1435
1436  my $remainder = POSIX::remainder($x, $y)
1437
1438 See also L</remquo>.
1439
1440 =item C<remove>
1441
1442 Deletes a name from the filesystem.  Calls L<perlfunc/unlink> for
1443 files and L<perlfunc/rmdir> for directories.
1444
1445 =item C<remquo>
1446
1447 Like L</remainder> but also returns the low-order bits of the quotient (n)
1448 [C99].  Added in Perl v5.22.
1449
1450 (This is quite esoteric interface, mainly used to implement numerical
1451 algorithms.)
1452
1453 =item C<rename>
1454
1455 This is identical to Perl's builtin C<rename()> function
1456 for renaming files, see L<perlfunc/rename>.
1457
1458 =item C<rewind>
1459
1460 Seeks to the beginning of the file.
1461
1462 =item C<rewinddir>
1463
1464 This is identical to Perl's builtin C<rewinddir()> function for
1465 rewinding directory entry streams, see L<perlfunc/rewinddir>.
1466
1467 =item C<rint>
1468
1469 Identical to L</lrint>.
1470
1471 =item C<rmdir>
1472
1473 This is identical to Perl's builtin C<rmdir()> function
1474 for removing (empty) directories, see L<perlfunc/rmdir>.
1475
1476 =item C<round>
1477
1478 Returns the integer (but still as floating point) nearest to the
1479 argument [C99].  Added in Perl v5.22.
1480
1481 See also L</ceil>, L</floor>, L</lround>, L</modf>, and L</trunc>.
1482
1483 =item C<scalbn>
1484
1485 Returns S<C<x * 2**y>> [C99].  Added in Perl v5.22.
1486
1487 See also L</frexp> and L</ldexp>.
1488
1489 =item C<scanf>
1490
1491 Not implemented.  C<scanf()> is C-specific, use E<lt>E<gt> and regular expressions instead,
1492 see L<perlre>.
1493
1494 =item C<setgid>
1495
1496 Sets the real group identifier and the effective group identifier for
1497 this process.  Similar to assigning a value to the Perl's builtin
1498 C<$)> variable, see L<perlvar/$EGID>, except that the latter
1499 will change only the real user identifier, and that the setgid()
1500 uses only a single numeric argument, as opposed to a space-separated
1501 list of numbers.
1502
1503 =item C<setjmp>
1504
1505 Not implemented.  C<setjmp()> is C-specific: use C<eval {}> instead,
1506 see L<perlfunc/eval>.
1507
1508 =item C<setlocale>
1509
1510 WARNING!  Prior to Perl 5.28 or on a system that does not support
1511 thread-safe locale operations, do NOT use this function in a
1512 L<thread|threads>.  The locale will change in all other threads at the
1513 same time, and should your thread get paused by the operating system,
1514 and another started, that thread will not have the locale it is
1515 expecting.  On some platforms, there can be a race leading to segfaults
1516 if two threads call this function nearly simultaneously.  This warning
1517 does not apply on unthreaded builds, or on perls where
1518 C<${^SAFE_LOCALES}> exists and is non-zero; namely Perl 5.28 and later
1519 compiled to be locale-thread-safe.
1520
1521 This function
1522 modifies and queries the program's underlying locale.  Users of this
1523 function should read L<perllocale>, whch provides a comprehensive
1524 discussion of Perl locale handling, knowledge of which is necessary to
1525 properly use this function.  It contains
1526 L<a section devoted to this function|perllocale/The setlocale function>.
1527 The discussion here is merely a summary reference for C<setlocale()>.
1528 Note that Perl itself is almost entirely unaffected by the locale
1529 except within the scope of S<C<"use locale">>.  (Exceptions are listed
1530 in L<perllocale/Not within the scope of "use locale">, and
1531 locale-dependent functions within the POSIX module ARE always affected
1532 by the current locale.)
1533
1534 The following examples assume
1535
1536         use POSIX qw(setlocale LC_ALL LC_CTYPE);
1537
1538 has been issued.
1539
1540 The following will set the traditional UNIX system locale behavior
1541 (the second argument C<"C">).
1542
1543         $loc = setlocale( LC_ALL, "C" );
1544
1545 The following will query the current C<LC_CTYPE> category.  (No second
1546 argument means 'query'.)
1547
1548         $loc = setlocale( LC_CTYPE );
1549
1550 The following will set the C<LC_CTYPE> behaviour according to the locale
1551 environment variables (the second argument C<"">).
1552 Please see your system's C<setlocale(3)> documentation for the locale
1553 environment variables' meaning or consult L<perllocale>.
1554
1555         $loc = setlocale( LC_CTYPE, "" );
1556
1557 The following will set the C<LC_COLLATE> behaviour to Argentinian
1558 Spanish. B<NOTE>: The naming and availability of locales depends on
1559 your operating system. Please consult L<perllocale> for how to find
1560 out which locales are available in your system.
1561
1562         $loc = setlocale( LC_COLLATE, "es_AR.ISO8859-1" );
1563
1564 =item C<setpayload>
1565
1566         use POSIX ':nan_payload';
1567         setpayload($var, $payload);
1568
1569 Sets the C<NaN> payload of var.  Added in Perl v5.24.
1570
1571 NOTE: the NaN payload APIs are based on the latest (as of June 2015)
1572 proposed ISO C interfaces, but they are not yet a standard.  Things
1573 may change.
1574
1575 See L</nan> for more discussion about C<NaN>.
1576
1577 See also L</setpayloadsig>, L</isnan>, L</getpayload>, and L</issignaling>.
1578
1579 =item C<setpayloadsig>
1580
1581         use POSIX ':nan_payload';
1582         setpayloadsig($var, $payload);
1583
1584 Like L</setpayload> but also makes the NaN I<signaling>.  Added in Perl
1585 v5.24.
1586
1587 Depending on the platform the NaN may or may not behave differently.
1588
1589 Note the API instability warning in L</setpayload>.
1590
1591 Note that because how the floating point formats work out, on the most
1592 common platforms signaling payload of zero is best avoided,
1593 since it might end up being identical to C<+Inf>.
1594
1595 See also L</nan>, L</isnan>, L</getpayload>, and L</issignaling>.
1596
1597 =item C<setpgid>
1598
1599 This is similar to the C function C<setpgid()> for
1600 setting the process group identifier of the current process.
1601
1602 Returns C<undef> on failure.
1603
1604 =item C<setsid>
1605
1606 This is identical to the C function C<setsid()> for
1607 setting the session identifier of the current process.
1608
1609 =item C<setuid>
1610
1611 Sets the real user identifier and the effective user identifier for
1612 this process.  Similar to assigning a value to the Perl's builtin
1613 C<$E<lt>> variable, see L<perlvar/$UID>, except that the latter
1614 will change only the real user identifier.
1615
1616 =item C<sigaction>
1617
1618 Detailed signal management.  This uses C<POSIX::SigAction> objects for
1619 the C<action> and C<oldaction> arguments (the oldaction can also be
1620 just a hash reference).  Consult your system's C<sigaction> manpage
1621 for details, see also C<POSIX::SigRt>.
1622
1623 Synopsis:
1624
1625         sigaction(signal, action, oldaction = 0)
1626
1627 Returns C<undef> on failure.  The C<signal> must be a number (like
1628 C<SIGHUP>), not a string (like C<"SIGHUP">), though Perl does try hard
1629 to understand you.
1630
1631 If you use the C<SA_SIGINFO> flag, the signal handler will in addition to
1632 the first argument, the signal name, also receive a second argument, a
1633 hash reference, inside which are the following keys with the following
1634 semantics, as defined by POSIX/SUSv3:
1635
1636     signo       the signal number
1637     errno       the error number
1638     code        if this is zero or less, the signal was sent by
1639                 a user process and the uid and pid make sense,
1640                 otherwise the signal was sent by the kernel
1641
1642 The constants for specific C<code> values can be imported individually
1643 or using the C<:signal_h_si_code> tag, since Perl v5.24.
1644
1645 The following are also defined by POSIX/SUSv3, but unfortunately
1646 not very widely implemented:
1647
1648     pid         the process id generating the signal
1649     uid         the uid of the process id generating the signal
1650     status      exit value or signal for SIGCHLD
1651     band        band event for SIGPOLL
1652     addr        address of faulting instruction or memory
1653                 reference for SIGILL, SIGFPE, SIGSEGV or SIGBUS
1654
1655 A third argument is also passed to the handler, which contains a copy
1656 of the raw binary contents of the C<siginfo> structure: if a system has
1657 some non-POSIX fields, this third argument is where to C<unpack()> them
1658 from.
1659
1660 Note that not all C<siginfo> values make sense simultaneously (some are
1661 valid only for certain signals, for example), and not all values make
1662 sense from Perl perspective, you should to consult your system's
1663 C<sigaction> and possibly also C<siginfo> documentation.
1664
1665 =item C<siglongjmp>
1666
1667 Not implemented.  C<siglongjmp()> is C-specific: use L<perlfunc/die> instead.
1668
1669 =item C<signbit>
1670
1671 Returns zero for positive arguments, non-zero for negative arguments [C99].
1672 Added in Perl v5.22.
1673
1674 =item C<sigpending>
1675
1676 Examine signals that are blocked and pending.  This uses C<POSIX::SigSet>
1677 objects for the C<sigset> argument.  Consult your system's C<sigpending>
1678 manpage for details.
1679
1680 Synopsis:
1681
1682         sigpending(sigset)
1683
1684 Returns C<undef> on failure.
1685
1686 =item C<sigprocmask>
1687
1688 Change and/or examine calling process's signal mask.  This uses
1689 C<POSIX::SigSet> objects for the C<sigset> and C<oldsigset> arguments.
1690 Consult your system's C<sigprocmask> manpage for details.
1691
1692 Synopsis:
1693
1694         sigprocmask(how, sigset, oldsigset = 0)
1695
1696 Returns C<undef> on failure.
1697
1698 Note that you can't reliably block or unblock a signal from its own signal
1699 handler if you're using safe signals. Other signals can be blocked or unblocked
1700 reliably.
1701
1702 =item C<sigsetjmp>
1703
1704 Not implemented.  C<sigsetjmp()> is C-specific: use C<eval {}> instead,
1705 see L<perlfunc/eval>.
1706
1707 =item C<sigsuspend>
1708
1709 Install a signal mask and suspend process until signal arrives.  This uses
1710 C<POSIX::SigSet> objects for the C<signal_mask> argument.  Consult your
1711 system's C<sigsuspend> manpage for details.
1712
1713 Synopsis:
1714
1715         sigsuspend(signal_mask)
1716
1717 Returns C<undef> on failure.
1718
1719 =item C<sin>
1720
1721 This is identical to Perl's builtin C<sin()> function
1722 for returning the sine of the numerical argument,
1723 see L<perlfunc/sin>.  See also L<Math::Trig>.
1724
1725 =item C<sinh>
1726
1727 This is identical to the C function C<sinh()>
1728 for returning the hyperbolic sine of the numerical argument.
1729 See also L<Math::Trig>.
1730
1731 =item C<sleep>
1732
1733 This is functionally identical to Perl's builtin C<sleep()> function
1734 for suspending the execution of the current for process for certain
1735 number of seconds, see L<perlfunc/sleep>.  There is one significant
1736 difference, however: C<POSIX::sleep()> returns the number of
1737 B<unslept> seconds, while the C<CORE::sleep()> returns the
1738 number of slept seconds.
1739
1740 =item C<sprintf>
1741
1742 This is similar to Perl's builtin C<sprintf()> function
1743 for returning a string that has the arguments formatted as requested,
1744 see L<perlfunc/sprintf>.
1745
1746 =item C<sqrt>
1747
1748 This is identical to Perl's builtin C<sqrt()> function.
1749 for returning the square root of the numerical argument,
1750 see L<perlfunc/sqrt>.
1751
1752 =item C<srand>
1753
1754 Give a seed the pseudorandom number generator, see L<perlfunc/srand>.
1755
1756 =item C<sscanf>
1757
1758 Not implemented.  C<sscanf()> is C-specific, use regular expressions instead,
1759 see L<perlre>.
1760
1761 =item C<stat>
1762
1763 This is identical to Perl's builtin C<stat()> function
1764 for returning information about files and directories.
1765
1766 =item C<strcat>
1767
1768 Not implemented.  C<strcat()> is C-specific, use C<.=> instead, see L<perlop>.
1769
1770 =item C<strchr>
1771
1772 Not implemented.  C<strchr()> is C-specific, see L<perlfunc/index> instead.
1773
1774 =item C<strcmp>
1775
1776 Not implemented.  C<strcmp()> is C-specific, use C<eq> or C<cmp> instead, see L<perlop>.
1777
1778 =item C<strcoll>
1779
1780 This is identical to the C function C<strcoll()>
1781 for collating (comparing) strings transformed using
1782 the C<strxfrm()> function.  Not really needed since
1783 Perl can do this transparently, see L<perllocale>.
1784
1785 Beware that in a UTF-8 locale, anything you pass to this function must
1786 be in UTF-8; and when not in a UTF-8 locale, anything passed must not be
1787 UTF-8 encoded.
1788
1789 =item C<strcpy>
1790
1791 Not implemented.  C<strcpy()> is C-specific, use C<=> instead, see L<perlop>.
1792
1793 =item C<strcspn>
1794
1795 Not implemented.  C<strcspn()> is C-specific, use regular expressions instead,
1796 see L<perlre>.
1797
1798 =item C<strerror>
1799
1800 Returns the error string for the specified errno.
1801 Identical to the string form of C<$!>, see L<perlvar/$ERRNO>.
1802
1803 =item C<strftime>
1804
1805 Convert date and time information to string.  Returns the string.
1806
1807 Synopsis:
1808
1809         strftime(fmt, sec, min, hour, mday, mon, year,
1810                  wday = -1, yday = -1, isdst = -1)
1811
1812 The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero,
1813 I<i.e.>, January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1.  The
1814 year (C<year>) is given in years since 1900, I<i.e.>, the year 1995 is 95; the
1815 year 2001 is 101.  Consult your system's C<strftime()> manpage for details
1816 about these and the other arguments.
1817
1818 If you want your code to be portable, your format (C<fmt>) argument
1819 should use only the conversion specifiers defined by the ANSI C
1820 standard (C89, to play safe).  These are C<aAbBcdHIjmMpSUwWxXyYZ%>.
1821 But even then, the B<results> of some of the conversion specifiers are
1822 non-portable.  For example, the specifiers C<aAbBcpZ> change according
1823 to the locale settings of the user, and both how to set locales (the
1824 locale names) and what output to expect are non-standard.
1825 The specifier C<c> changes according to the timezone settings of the
1826 user and the timezone computation rules of the operating system.
1827 The C<Z> specifier is notoriously unportable since the names of
1828 timezones are non-standard. Sticking to the numeric specifiers is the
1829 safest route.
1830
1831 The given arguments are made consistent as though by calling
1832 C<mktime()> before calling your system's C<strftime()> function,
1833 except that the C<isdst> value is not affected.
1834
1835 The string for Tuesday, December 12, 1995.
1836
1837         $str = POSIX::strftime( "%A, %B %d, %Y",
1838                                  0, 0, 0, 12, 11, 95, 2 );
1839         print "$str\n";
1840
1841 =item C<strlen>
1842
1843 Not implemented.  C<strlen()> is C-specific, use C<length()> instead, see L<perlfunc/length>.
1844
1845 =item C<strncat>
1846
1847 Not implemented.  C<strncat()> is C-specific, use C<.=> instead, see L<perlop>.
1848
1849 =item C<strncmp>
1850
1851 Not implemented.  C<strncmp()> is C-specific, use C<eq> instead, see L<perlop>.
1852
1853 =item C<strncpy>
1854
1855 Not implemented.  C<strncpy()> is C-specific, use C<=> instead, see L<perlop>.
1856
1857 =item C<strpbrk>
1858
1859 Not implemented.  C<strpbrk()> is C-specific, use regular expressions instead,
1860 see L<perlre>.
1861
1862 =item C<strrchr>
1863
1864 Not implemented.  C<strrchr()> is C-specific, see L<perlfunc/rindex> instead.
1865
1866 =item C<strspn>
1867
1868 Not implemented.  C<strspn()> is C-specific, use regular expressions instead,
1869 see L<perlre>.
1870
1871 =item C<strstr>
1872
1873 This is identical to Perl's builtin C<index()> function,
1874 see L<perlfunc/index>.
1875
1876 =item C<strtod>
1877
1878 String to double translation. Returns the parsed number and the number
1879 of characters in the unparsed portion of the string.  Truly
1880 POSIX-compliant systems set C<$!> (C<$ERRNO>) to indicate a translation
1881 error, so clear C<$!> before calling C<strtod>.  However, non-POSIX systems
1882 may not check for overflow, and therefore will never set C<$!>.
1883
1884 C<strtod> respects any POSIX C<setlocale()> C<LC_NUMERIC> settings,
1885 regardless of whether or not it is called from Perl code that is within
1886 the scope of S<C<use locale>>.  Prior to Perl 5.28, or when operating in
1887 a non thread-safe environment, it should not be used in a threaded
1888 application unless it's certain that the underlying locale is C
1889 or POSIX.  This is because it otherwise changes the locale, which
1890 globally affects all threads simultaneously.
1891
1892 To parse a string C<$str> as a floating point number use
1893
1894     $! = 0;
1895     ($num, $n_unparsed) = POSIX::strtod($str);
1896
1897 The second returned item and C<$!> can be used to check for valid input:
1898
1899     if (($str eq '') || ($n_unparsed != 0) || $!) {
1900         die "Non-numeric input $str" . ($! ? ": $!\n" : "\n");
1901     }
1902
1903 When called in a scalar context C<strtod> returns the parsed number.
1904
1905 =item C<strtok>
1906
1907 Not implemented.  C<strtok()> is C-specific, use regular expressions instead, see
1908 L<perlre>, or L<perlfunc/split>.
1909
1910 =item C<strtol>
1911
1912 String to (long) integer translation.  Returns the parsed number and
1913 the number of characters in the unparsed portion of the string.  Truly
1914 POSIX-compliant systems set C<$!> (C<$ERRNO>) to indicate a translation
1915 error, so clear C<$!> before calling C<strtol>.  However, non-POSIX systems
1916 may not check for overflow, and therefore will never set C<$!>.
1917
1918 C<strtol> should respect any POSIX I<setlocale()> settings.
1919
1920 To parse a string C<$str> as a number in some base C<$base> use
1921
1922     $! = 0;
1923     ($num, $n_unparsed) = POSIX::strtol($str, $base);
1924
1925 The base should be zero or between 2 and 36, inclusive.  When the base
1926 is zero or omitted C<strtol> will use the string itself to determine the
1927 base: a leading "0x" or "0X" means hexadecimal; a leading "0" means
1928 octal; any other leading characters mean decimal.  Thus, "1234" is
1929 parsed as a decimal number, "01234" as an octal number, and "0x1234"
1930 as a hexadecimal number.
1931
1932 The second returned item and C<$!> can be used to check for valid input:
1933
1934     if (($str eq '') || ($n_unparsed != 0) || !$!) {
1935         die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
1936     }
1937
1938 When called in a scalar context C<strtol> returns the parsed number.
1939
1940 =item C<strtold>
1941
1942 Like L</strtod> but for long doubles.  Defined only if the
1943 system supports long doubles.
1944
1945 =item C<strtoul>
1946
1947 String to unsigned (long) integer translation.  C<strtoul()> is identical
1948 to C<strtol()> except that C<strtoul()> only parses unsigned integers.  See
1949 L</strtol> for details.
1950
1951 Note: Some vendors supply C<strtod()> and C<strtol()> but not C<strtoul()>.
1952 Other vendors that do supply C<strtoul()> parse "-1" as a valid value.
1953
1954 =item C<strxfrm>
1955
1956 String transformation.  Returns the transformed string.
1957
1958         $dst = POSIX::strxfrm( $src );
1959
1960 Used in conjunction with the C<strcoll()> function, see L</strcoll>.
1961
1962 Not really needed since Perl can do this transparently, see
1963 L<perllocale>.
1964
1965 Beware that in a UTF-8 locale, anything you pass to this function must
1966 be in UTF-8; and when not in a UTF-8 locale, anything passed must not be
1967 UTF-8 encoded.
1968
1969 =item C<sysconf>
1970
1971 Retrieves values of system configurable variables.
1972
1973 The following will get the machine's clock speed.
1974
1975         $clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
1976
1977 Returns C<undef> on failure.
1978
1979 =item C<system>
1980
1981 This is identical to Perl's builtin C<system()> function, see
1982 L<perlfunc/system>.
1983
1984 =item C<tan>
1985
1986 This is identical to the C function C<tan()>, returning the
1987 tangent of the numerical argument.  See also L<Math::Trig>.
1988
1989 =item C<tanh>
1990
1991 This is identical to the C function C<tanh()>, returning the
1992 hyperbolic tangent of the numerical argument.   See also L<Math::Trig>.
1993
1994 =item C<tcdrain>
1995
1996 This is similar to the C function C<tcdrain()> for draining
1997 the output queue of its argument stream.
1998
1999 Returns C<undef> on failure.
2000
2001 =item C<tcflow>
2002
2003 This is similar to the C function C<tcflow()> for controlling
2004 the flow of its argument stream.
2005
2006 Returns C<undef> on failure.
2007
2008 =item C<tcflush>
2009
2010 This is similar to the C function C<tcflush()> for flushing
2011 the I/O buffers of its argument stream.
2012
2013 Returns C<undef> on failure.
2014
2015 =item C<tcgetpgrp>
2016
2017 This is identical to the C function C<tcgetpgrp()> for returning the
2018 process group identifier of the foreground process group of the controlling
2019 terminal.
2020
2021 =item C<tcsendbreak>
2022
2023 This is similar to the C function C<tcsendbreak()> for sending
2024 a break on its argument stream.
2025
2026 Returns C<undef> on failure.
2027
2028 =item C<tcsetpgrp>
2029
2030 This is similar to the C function C<tcsetpgrp()> for setting the
2031 process group identifier of the foreground process group of the controlling
2032 terminal.
2033
2034 Returns C<undef> on failure.
2035
2036 =item C<tgamma>
2037
2038 The Gamma function [C99].  Added in Perl v5.22.
2039
2040 See also L</lgamma>.
2041
2042 =item C<time>
2043
2044 This is identical to Perl's builtin C<time()> function
2045 for returning the number of seconds since the epoch
2046 (whatever it is for the system), see L<perlfunc/time>.
2047
2048 =item C<times>
2049
2050 The C<times()> function returns elapsed realtime since some point in the past
2051 (such as system startup), user and system times for this process, and user
2052 and system times used by child processes.  All times are returned in clock
2053 ticks.
2054
2055     ($realtime, $user, $system, $cuser, $csystem)
2056         = POSIX::times();
2057
2058 Note: Perl's builtin C<times()> function returns four values, measured in
2059 seconds.
2060
2061 =item C<tmpfile>
2062
2063 Not implemented.  Use method C<IO::File::new_tmpfile()> instead, or see L<File::Temp>.
2064
2065 =item C<tmpnam>
2066
2067 For security reasons, which are probably detailed in your system's
2068 documentation for the C library C<tmpnam()> function, this interface
2069 is no longer available since Perl v5.26; instead use L<File::Temp>.
2070
2071 =item C<tolower>
2072
2073 This function has been removed as of Perl v5.26.
2074 This is identical to the C function, except that it can apply to a single
2075 character or to a whole string, and currently operates as if the locale
2076 always is "C".  Consider using the C<lc()> function, see L<perlfunc/lc>,
2077 see L<perlfunc/lc>, or the equivalent C<\L> operator inside doublequotish
2078 strings.
2079
2080 =item C<toupper>
2081
2082 This function has been removed as of Perl v5.26.
2083 This is similar to the C function, except that it can apply to a single
2084 character or to a whole string, and currently operates as if the locale
2085 always is "C".  Consider using the C<uc()> function, see L<perlfunc/uc>,
2086 or the equivalent C<\U> operator inside doublequotish strings.
2087
2088 =item C<trunc>
2089
2090 Returns the integer toward zero from the argument [C99].  Added in Perl
2091 v5.22.
2092
2093 See also L</ceil>, L</floor>, and L</round>.
2094
2095 =item C<ttyname>
2096
2097 This is identical to the C function C<ttyname()> for returning the
2098 name of the current terminal.
2099
2100 =item C<tzname>
2101
2102 Retrieves the time conversion information from the C<tzname> variable.
2103
2104         POSIX::tzset();
2105         ($std, $dst) = POSIX::tzname();
2106
2107 =item C<tzset>
2108
2109 This is identical to the C function C<tzset()> for setting
2110 the current timezone based on the environment variable C<TZ>,
2111 to be used by C<ctime()>, C<localtime()>, C<mktime()>, and C<strftime()>
2112 functions.
2113
2114 =item C<umask>
2115
2116 This is identical to Perl's builtin C<umask()> function
2117 for setting (and querying) the file creation permission mask,
2118 see L<perlfunc/umask>.
2119
2120 =item C<uname>
2121
2122 Get name of current operating system.
2123
2124         ($sysname, $nodename, $release, $version, $machine)
2125                 = POSIX::uname();
2126
2127 Note that the actual meanings of the various fields are not
2128 that well standardized, do not expect any great portability.
2129 The C<$sysname> might be the name of the operating system,
2130 the C<$nodename> might be the name of the host, the C<$release>
2131 might be the (major) release number of the operating system,
2132 the C<$version> might be the (minor) release number of the
2133 operating system, and the C<$machine> might be a hardware identifier.
2134 Maybe.
2135
2136 =item C<ungetc>
2137
2138 Not implemented.  Use method C<IO::Handle::ungetc()> instead.
2139
2140 =item C<unlink>
2141
2142 This is identical to Perl's builtin C<unlink()> function
2143 for removing files, see L<perlfunc/unlink>.
2144
2145 =item C<utime>
2146
2147 This is identical to Perl's builtin C<utime()> function
2148 for changing the time stamps of files and directories,
2149 see L<perlfunc/utime>.
2150
2151 =item C<vfprintf>
2152
2153 Not implemented.  C<vfprintf()> is C-specific, see L<perlfunc/printf> instead.
2154
2155 =item C<vprintf>
2156
2157 Not implemented.  C<vprintf()> is C-specific, see L<perlfunc/printf> instead.
2158
2159 =item C<vsprintf>
2160
2161 Not implemented.  C<vsprintf()> is C-specific, see L<perlfunc/sprintf> instead.
2162
2163 =item C<wait>
2164
2165 This is identical to Perl's builtin C<wait()> function,
2166 see L<perlfunc/wait>.
2167
2168 =item C<waitpid>
2169
2170 Wait for a child process to change state.  This is identical to Perl's
2171 builtin C<waitpid()> function, see L<perlfunc/waitpid>.
2172
2173         $pid = POSIX::waitpid( -1, POSIX::WNOHANG );
2174         print "status = ", ($? / 256), "\n";
2175
2176 See L</mblen>.
2177
2178 =item C<wctomb>
2179
2180 This is the same as the C function C<wctomb()> on unthreaded perls.  On
2181 threaded perls, it transparently (almost) substitutes the more
2182 thread-safe L<C<wcrtomb>(3)>, if available, instead of C<wctomb>.
2183
2184 Core Perl does not have any support for wide and multibyte locales,
2185 except Unicode UTF-8 locales.  This function, in conjunction with
2186 L</mblen> and L</mbtowc> may be used to roll your own decoding/encoding
2187 of other types of multi-byte locales.
2188
2189 Use C<undef> as the first parameter to this function to get the effect
2190 of passing NULL as the first parameter to C<wctomb>.  This resets any
2191 shift state to its initial value.  The return value is undefined if
2192 C<wcrtomb> was substituted, so you should never rely on it.
2193
2194 When the first parameter is a scalar, the code point contained in the
2195 scalar second parameter is converted into a multi-byte string and stored
2196 into the first parameter scalar.  This is based on the locale that
2197 currently underlies the program, regardless of whether or not the
2198 function is called from Perl code that is within the scope of S<C<use
2199 locale>>.  The return value is the number of bytes stored; or negative
2200 if the code point isn't representable in the current locale.  Perl makes
2201 no attempt at hiding from your code any differences in the C<errno>
2202 setting between C<wctomb> and C<wcrtomb>.  It does set C<errno> to 0
2203 before calling them.
2204
2205 =item C<write>
2206
2207 Write to a file.  This uses file descriptors such as those obtained by
2208 calling C<POSIX::open>.
2209
2210         $fd = POSIX::open( "foo", &POSIX::O_WRONLY );
2211         $buf = "hello";
2212         $bytes = POSIX::write( $fd, $buf, 5 );
2213
2214 Returns C<undef> on failure.
2215
2216 See also L<perlfunc/syswrite>.
2217
2218 =back
2219
2220 =head1 CLASSES
2221
2222 =head2 C<POSIX::SigAction>
2223
2224 =over 8
2225
2226 =item C<new>
2227
2228 Creates a new C<POSIX::SigAction> object which corresponds to the C
2229 C<struct sigaction>.  This object will be destroyed automatically when
2230 it is no longer needed.  The first parameter is the handler, a sub
2231 reference.  The second parameter is a C<POSIX::SigSet> object, it
2232 defaults to the empty set.  The third parameter contains the
2233 C<sa_flags>, it defaults to 0.
2234
2235         $sigset = POSIX::SigSet->new(SIGINT, SIGQUIT);
2236         $sigaction = POSIX::SigAction->new(
2237                         \&handler, $sigset, &POSIX::SA_NOCLDSTOP
2238                      );
2239
2240 This C<POSIX::SigAction> object is intended for use with the C<POSIX::sigaction()>
2241 function.
2242
2243 =back
2244
2245 =over 8
2246
2247 =item C<handler>
2248
2249 =item C<mask>
2250
2251 =item C<flags>
2252
2253 accessor functions to get/set the values of a SigAction object.
2254
2255         $sigset = $sigaction->mask;
2256         $sigaction->flags(&POSIX::SA_RESTART);
2257
2258 =item C<safe>
2259
2260 accessor function for the "safe signals" flag of a SigAction object; see
2261 L<perlipc> for general information on safe (a.k.a. "deferred") signals.  If
2262 you wish to handle a signal safely, use this accessor to set the "safe" flag
2263 in the C<POSIX::SigAction> object:
2264
2265         $sigaction->safe(1);
2266
2267 You may also examine the "safe" flag on the output action object which is
2268 filled in when given as the third parameter to C<POSIX::sigaction()>:
2269
2270         sigaction(SIGINT, $new_action, $old_action);
2271         if ($old_action->safe) {
2272             # previous SIGINT handler used safe signals
2273         }
2274
2275 =back
2276
2277 =head2 C<POSIX::SigRt>
2278
2279 =over 8
2280
2281 =item C<%SIGRT>
2282
2283 A hash of the POSIX realtime signal handlers.  It is an extension of
2284 the standard C<%SIG>, the C<$POSIX::SIGRT{SIGRTMIN}> is roughly equivalent
2285 to C<$SIG{SIGRTMIN}>, but the right POSIX moves (see below) are made with
2286 the C<POSIX::SigSet> and C<POSIX::sigaction> instead of accessing the C<%SIG>.
2287
2288 You can set the C<%POSIX::SIGRT> elements to set the POSIX realtime
2289 signal handlers, use C<delete> and C<exists> on the elements, and use
2290 C<scalar> on the C<%POSIX::SIGRT> to find out how many POSIX realtime
2291 signals there are available S<C<(SIGRTMAX - SIGRTMIN + 1>>, the C<SIGRTMAX> is
2292 a valid POSIX realtime signal).
2293
2294 Setting the C<%SIGRT> elements is equivalent to calling this:
2295
2296   sub new {
2297     my ($rtsig, $handler, $flags) = @_;
2298     my $sigset = POSIX::SigSet($rtsig);
2299     my $sigact = POSIX::SigAction->new($handler,$sigset,$flags);
2300     sigaction($rtsig, $sigact);
2301   }
2302
2303 The flags default to zero, if you want something different you can
2304 either use C<local> on C<$POSIX::SigRt::SIGACTION_FLAGS>, or you can
2305 derive from POSIX::SigRt and define your own C<new()> (the tied hash
2306 STORE method of the C<%SIGRT> calls C<new($rtsig, $handler, $SIGACTION_FLAGS)>,
2307 where the C<$rtsig> ranges from zero to S<C<SIGRTMAX - SIGRTMIN + 1)>>.
2308
2309 Just as with any signal, you can use C<sigaction($rtsig, undef, $oa)> to
2310 retrieve the installed signal handler (or, rather, the signal action).
2311
2312 B<NOTE:> whether POSIX realtime signals really work in your system, or
2313 whether Perl has been compiled so that it works with them, is outside
2314 of this discussion.
2315
2316 =item C<SIGRTMIN>
2317
2318 Return the minimum POSIX realtime signal number available, or C<undef>
2319 if no POSIX realtime signals are available.
2320
2321 =item C<SIGRTMAX>
2322
2323 Return the maximum POSIX realtime signal number available, or C<undef>
2324 if no POSIX realtime signals are available.
2325
2326 =back
2327
2328 =head2 C<POSIX::SigSet>
2329
2330 =over 8
2331
2332 =item C<new>
2333
2334 Create a new SigSet object.  This object will be destroyed automatically
2335 when it is no longer needed.  Arguments may be supplied to initialize the
2336 set.
2337
2338 Create an empty set.
2339
2340         $sigset = POSIX::SigSet->new;
2341
2342 Create a set with C<SIGUSR1>.
2343
2344         $sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 );
2345
2346 Throws an error if any of the signals supplied cannot be added to the
2347 set.
2348
2349 =item C<addset>
2350
2351 Add a signal to a SigSet object.
2352
2353         $sigset->addset( &POSIX::SIGUSR2 );
2354
2355 Returns C<undef> on failure.
2356
2357 =item C<delset>
2358
2359 Remove a signal from the SigSet object.
2360
2361         $sigset->delset( &POSIX::SIGUSR2 );
2362
2363 Returns C<undef> on failure.
2364
2365 =item C<emptyset>
2366
2367 Initialize the SigSet object to be empty.
2368
2369         $sigset->emptyset();
2370
2371 Returns C<undef> on failure.
2372
2373 =item C<fillset>
2374
2375 Initialize the SigSet object to include all signals.
2376
2377         $sigset->fillset();
2378
2379 Returns C<undef> on failure.
2380
2381 =item C<ismember>
2382
2383 Tests the SigSet object to see if it contains a specific signal.
2384
2385         if( $sigset->ismember( &POSIX::SIGUSR1 ) ){
2386                 print "contains SIGUSR1\n";
2387         }
2388
2389 =back
2390
2391 =head2 C<POSIX::Termios>
2392
2393 =over 8
2394
2395 =item C<new>
2396
2397 Create a new Termios object.  This object will be destroyed automatically
2398 when it is no longer needed.  A Termios object corresponds to the C<termios>
2399 C struct.  C<new()> mallocs a new one, C<getattr()> fills it from a file descriptor,
2400 and C<setattr()> sets a file descriptor's parameters to match Termios' contents.
2401
2402         $termios = POSIX::Termios->new;
2403
2404 =item C<getattr>
2405
2406 Get terminal control attributes.
2407
2408 Obtain the attributes for C<stdin>.
2409
2410         $termios->getattr( 0 ) # Recommended for clarity.
2411         $termios->getattr()
2412
2413 Obtain the attributes for stdout.
2414
2415         $termios->getattr( 1 )
2416
2417 Returns C<undef> on failure.
2418
2419 =item C<getcc>
2420
2421 Retrieve a value from the C<c_cc> field of a C<termios> object.  The C<c_cc> field is
2422 an array so an index must be specified.
2423
2424         $c_cc[1] = $termios->getcc(1);
2425
2426 =item C<getcflag>
2427
2428 Retrieve the C<c_cflag> field of a C<termios> object.
2429
2430         $c_cflag = $termios->getcflag;
2431
2432 =item C<getiflag>
2433
2434 Retrieve the C<c_iflag> field of a C<termios> object.
2435
2436         $c_iflag = $termios->getiflag;
2437
2438 =item C<getispeed>
2439
2440 Retrieve the input baud rate.
2441
2442         $ispeed = $termios->getispeed;
2443
2444 =item C<getlflag>
2445
2446 Retrieve the C<c_lflag> field of a C<termios> object.
2447
2448         $c_lflag = $termios->getlflag;
2449
2450 =item C<getoflag>
2451
2452 Retrieve the C<c_oflag> field of a C<termios> object.
2453
2454         $c_oflag = $termios->getoflag;
2455
2456 =item C<getospeed>
2457
2458 Retrieve the output baud rate.
2459
2460         $ospeed = $termios->getospeed;
2461
2462 =item C<setattr>
2463
2464 Set terminal control attributes.
2465
2466 Set attributes immediately for stdout.
2467
2468         $termios->setattr( 1, &POSIX::TCSANOW );
2469
2470 Returns C<undef> on failure.
2471
2472 =item C<setcc>
2473
2474 Set a value in the C<c_cc> field of a C<termios> object.  The C<c_cc> field is an
2475 array so an index must be specified.
2476
2477         $termios->setcc( &POSIX::VEOF, 1 );
2478
2479 =item C<setcflag>
2480
2481 Set the C<c_cflag> field of a C<termios> object.
2482
2483         $termios->setcflag( $c_cflag | &POSIX::CLOCAL );
2484
2485 =item C<setiflag>
2486
2487 Set the C<c_iflag> field of a C<termios> object.
2488
2489         $termios->setiflag( $c_iflag | &POSIX::BRKINT );
2490
2491 =item C<setispeed>
2492
2493 Set the input baud rate.
2494
2495         $termios->setispeed( &POSIX::B9600 );
2496
2497 Returns C<undef> on failure.
2498
2499 =item C<setlflag>
2500
2501 Set the C<c_lflag> field of a C<termios> object.
2502
2503         $termios->setlflag( $c_lflag | &POSIX::ECHO );
2504
2505 =item C<setoflag>
2506
2507 Set the C<c_oflag> field of a C<termios> object.
2508
2509         $termios->setoflag( $c_oflag | &POSIX::OPOST );
2510
2511 =item C<setospeed>
2512
2513 Set the output baud rate.
2514
2515         $termios->setospeed( &POSIX::B9600 );
2516
2517 Returns C<undef> on failure.
2518
2519 =item Baud rate values
2520
2521 C<B38400> C<B75> C<B200> C<B134> C<B300> C<B1800> C<B150> C<B0> C<B19200> C<B1200> C<B9600> C<B600> C<B4800> C<B50> C<B2400> C<B110>
2522
2523 =item Terminal interface values
2524
2525 C<TCSADRAIN> C<TCSANOW> C<TCOON> C<TCIOFLUSH> C<TCOFLUSH> C<TCION> C<TCIFLUSH> C<TCSAFLUSH> C<TCIOFF> C<TCOOFF>
2526
2527 =item C<c_cc> field values
2528
2529 C<VEOF> C<VEOL> C<VERASE> C<VINTR> C<VKILL> C<VQUIT> C<VSUSP> C<VSTART> C<VSTOP> C<VMIN> C<VTIME> C<NCCS>
2530
2531 =item C<c_cflag> field values
2532
2533 C<CLOCAL> C<CREAD> C<CSIZE> C<CS5> C<CS6> C<CS7> C<CS8> C<CSTOPB> C<HUPCL> C<PARENB> C<PARODD>
2534
2535 =item C<c_iflag> field values
2536
2537 C<BRKINT> C<ICRNL> C<IGNBRK> C<IGNCR> C<IGNPAR> C<INLCR> C<INPCK> C<ISTRIP> C<IXOFF> C<IXON> C<PARMRK>
2538
2539 =item C<c_lflag> field values
2540
2541 C<ECHO> C<ECHOE> C<ECHOK> C<ECHONL> C<ICANON> C<IEXTEN> C<ISIG> C<NOFLSH> C<TOSTOP>
2542
2543 =item C<c_oflag> field values
2544
2545 C<OPOST>
2546
2547 =back
2548
2549 =head1 PATHNAME CONSTANTS
2550
2551 =over 8
2552
2553 =item Constants
2554
2555 C<_PC_CHOWN_RESTRICTED> C<_PC_LINK_MAX> C<_PC_MAX_CANON> C<_PC_MAX_INPUT> C<_PC_NAME_MAX>
2556 C<_PC_NO_TRUNC> C<_PC_PATH_MAX> C<_PC_PIPE_BUF> C<_PC_VDISABLE>
2557
2558 =back
2559
2560 =head1 POSIX CONSTANTS
2561
2562 =over 8
2563
2564 =item Constants
2565
2566 C<_POSIX_ARG_MAX> C<_POSIX_CHILD_MAX> C<_POSIX_CHOWN_RESTRICTED> C<_POSIX_JOB_CONTROL>
2567 C<_POSIX_LINK_MAX> C<_POSIX_MAX_CANON> C<_POSIX_MAX_INPUT> C<_POSIX_NAME_MAX>
2568 C<_POSIX_NGROUPS_MAX> C<_POSIX_NO_TRUNC> C<_POSIX_OPEN_MAX> C<_POSIX_PATH_MAX>
2569 C<_POSIX_PIPE_BUF> C<_POSIX_SAVED_IDS> C<_POSIX_SSIZE_MAX> C<_POSIX_STREAM_MAX>
2570 C<_POSIX_TZNAME_MAX> C<_POSIX_VDISABLE> C<_POSIX_VERSION>
2571
2572 =back
2573
2574 =head1 RESOURCE CONSTANTS
2575
2576 Imported with the C<:sys_resource_h> tag.
2577
2578 =over 8
2579
2580 =item Constants
2581
2582 Added in Perl v5.28:
2583
2584 C<PRIO_PROCESS> C<PRIO_PGRP> C<PRIO_USER>
2585
2586 =back
2587
2588 =head1 SYSTEM CONFIGURATION
2589
2590 =over 8
2591
2592 =item Constants
2593
2594 C<_SC_ARG_MAX> C<_SC_CHILD_MAX> C<_SC_CLK_TCK> C<_SC_JOB_CONTROL> C<_SC_NGROUPS_MAX>
2595 C<_SC_OPEN_MAX> C<_SC_PAGESIZE> C<_SC_SAVED_IDS> C<_SC_STREAM_MAX> C<_SC_TZNAME_MAX>
2596 C<_SC_VERSION>
2597
2598 =back
2599
2600 =head1 ERRNO
2601
2602 =over 8
2603
2604 =item Constants
2605
2606 C<E2BIG> C<EACCES> C<EADDRINUSE> C<EADDRNOTAVAIL> C<EAFNOSUPPORT> C<EAGAIN> C<EALREADY> C<EBADF> C<EBADMSG>
2607 C<EBUSY> C<ECANCELED> C<ECHILD> C<ECONNABORTED> C<ECONNREFUSED> C<ECONNRESET> C<EDEADLK> C<EDESTADDRREQ>
2608 C<EDOM> C<EDQUOT> C<EEXIST> C<EFAULT> C<EFBIG> C<EHOSTDOWN> C<EHOSTUNREACH> C<EIDRM> C<EILSEQ> C<EINPROGRESS>
2609 C<EINTR> C<EINVAL> C<EIO> C<EISCONN> C<EISDIR> C<ELOOP> C<EMFILE> C<EMLINK> C<EMSGSIZE> C<ENAMETOOLONG>
2610 C<ENETDOWN> C<ENETRESET> C<ENETUNREACH> C<ENFILE> C<ENOBUFS> C<ENODATA> C<ENODEV> C<ENOENT> C<ENOEXEC>
2611 C<ENOLCK> C<ENOLINK> C<ENOMEM> C<ENOMSG> C<ENOPROTOOPT> C<ENOSPC> C<ENOSR> C<ENOSTR> C<ENOSYS> C<ENOTBLK>
2612 C<ENOTCONN> C<ENOTDIR> C<ENOTEMPTY> C<ENOTRECOVERABLE> C<ENOTSOCK> C<ENOTSUP> C<ENOTTY> C<ENXIO>
2613 C<EOPNOTSUPP> C<EOTHER> C<EOVERFLOW> C<EOWNERDEAD> C<EPERM> C<EPFNOSUPPORT> C<EPIPE> C<EPROCLIM> C<EPROTO>
2614 C<EPROTONOSUPPORT> C<EPROTOTYPE> C<ERANGE> C<EREMOTE> C<ERESTART> C<EROFS> C<ESHUTDOWN>
2615 C<ESOCKTNOSUPPORT> C<ESPIPE> C<ESRCH> C<ESTALE> C<ETIME> C<ETIMEDOUT> C<ETOOMANYREFS> C<ETXTBSY> C<EUSERS>
2616 C<EWOULDBLOCK> C<EXDEV>
2617
2618 =back
2619
2620 =head1 FCNTL
2621
2622 =over 8
2623
2624 =item Constants
2625
2626 C<FD_CLOEXEC> C<F_DUPFD> C<F_GETFD> C<F_GETFL> C<F_GETLK> C<F_OK> C<F_RDLCK> C<F_SETFD> C<F_SETFL> C<F_SETLK>
2627 C<F_SETLKW> C<F_UNLCK> C<F_WRLCK> C<O_ACCMODE> C<O_APPEND> C<O_CREAT> C<O_EXCL> C<O_NOCTTY> C<O_NONBLOCK>
2628 C<O_RDONLY> C<O_RDWR> C<O_TRUNC> C<O_WRONLY>
2629
2630 =back
2631
2632 =head1 FLOAT
2633
2634 =over 8
2635
2636 =item Constants
2637
2638 C<DBL_DIG> C<DBL_EPSILON> C<DBL_MANT_DIG> C<DBL_MAX> C<DBL_MAX_10_EXP> C<DBL_MAX_EXP> C<DBL_MIN>
2639 C<DBL_MIN_10_EXP> C<DBL_MIN_EXP> C<FLT_DIG> C<FLT_EPSILON> C<FLT_MANT_DIG> C<FLT_MAX>
2640 C<FLT_MAX_10_EXP> C<FLT_MAX_EXP> C<FLT_MIN> C<FLT_MIN_10_EXP> C<FLT_MIN_EXP> C<FLT_RADIX>
2641 C<FLT_ROUNDS> C<LDBL_DIG> C<LDBL_EPSILON> C<LDBL_MANT_DIG> C<LDBL_MAX> C<LDBL_MAX_10_EXP>
2642 C<LDBL_MAX_EXP> C<LDBL_MIN> C<LDBL_MIN_10_EXP> C<LDBL_MIN_EXP>
2643
2644 =back
2645
2646 =head1 FLOATING-POINT ENVIRONMENT
2647
2648 =over 8
2649
2650 =item Constants
2651
2652 C<FE_DOWNWARD> C<FE_TONEAREST> C<FE_TOWARDZERO> C<FE_UPWARD>
2653 on systems that support them.
2654
2655 =back
2656
2657 =head1 LIMITS
2658
2659 =over 8
2660
2661 =item Constants
2662
2663 C<ARG_MAX> C<CHAR_BIT> C<CHAR_MAX> C<CHAR_MIN> C<CHILD_MAX> C<INT_MAX> C<INT_MIN> C<LINK_MAX> C<LONG_MAX>
2664 C<LONG_MIN> C<MAX_CANON> C<MAX_INPUT> C<MB_LEN_MAX> C<NAME_MAX> C<NGROUPS_MAX> C<OPEN_MAX> C<PATH_MAX>
2665 C<PIPE_BUF> C<SCHAR_MAX> C<SCHAR_MIN> C<SHRT_MAX> C<SHRT_MIN> C<SSIZE_MAX> C<STREAM_MAX> C<TZNAME_MAX>
2666 C<UCHAR_MAX> C<UINT_MAX> C<ULONG_MAX> C<USHRT_MAX>
2667
2668 =back
2669
2670 =head1 LOCALE
2671
2672 =over 8
2673
2674 =item Constants
2675
2676 C<LC_ALL> C<LC_COLLATE> C<LC_CTYPE> C<LC_MONETARY> C<LC_NUMERIC> C<LC_TIME> C<LC_MESSAGES>
2677 on systems that support them.
2678
2679 =back
2680
2681 =head1 MATH
2682
2683 =over 8
2684
2685 =item Constants
2686
2687 C<HUGE_VAL>
2688
2689 Added in Perl v5.22:
2690
2691 C<FP_ILOGB0> C<FP_ILOGBNAN> C<FP_INFINITE> C<FP_NAN> C<FP_NORMAL> C<FP_SUBNORMAL> C<FP_ZERO>
2692 C<INFINITY> C<NAN> C<Inf> C<NaN>
2693 C<M_1_PI> C<M_2_PI> C<M_2_SQRTPI> C<M_E> C<M_LN10> C<M_LN2> C<M_LOG10E> C<M_LOG2E> C<M_PI>
2694 C<M_PI_2> C<M_PI_4> C<M_SQRT1_2> C<M_SQRT2>
2695 on systems with C99 support.
2696
2697 =back
2698
2699 =head1 SIGNAL
2700
2701 =over 8
2702
2703 =item Constants
2704
2705 C<SA_NOCLDSTOP> C<SA_NOCLDWAIT> C<SA_NODEFER> C<SA_ONSTACK> C<SA_RESETHAND> C<SA_RESTART>
2706 C<SA_SIGINFO> C<SIGABRT> C<SIGALRM> C<SIGCHLD> C<SIGCONT> C<SIGFPE> C<SIGHUP> C<SIGILL> C<SIGINT>
2707 C<SIGKILL> C<SIGPIPE> C<SIGQUIT> C<SIGSEGV> C<SIGSTOP> C<SIGTERM> C<SIGTSTP> C<SIGTTIN> C<SIGTTOU>
2708 C<SIGUSR1> C<SIGUSR2> C<SIG_BLOCK> C<SIG_DFL> C<SIG_ERR> C<SIG_IGN> C<SIG_SETMASK>
2709 C<SIG_UNBLOCK>
2710
2711 Added in Perl v5.24:
2712
2713 C<ILL_ILLOPC> C<ILL_ILLOPN> C<ILL_ILLADR> C<ILL_ILLTRP> C<ILL_PRVOPC> C<ILL_PRVREG> C<ILL_COPROC>
2714 C<ILL_BADSTK> C<FPE_INTDIV> C<FPE_INTOVF> C<FPE_FLTDIV> C<FPE_FLTOVF> C<FPE_FLTUND> C<FPE_FLTRES>
2715 C<FPE_FLTINV> C<FPE_FLTSUB> C<SEGV_MAPERR> C<SEGV_ACCERR> C<BUS_ADRALN> C<BUS_ADRERR>
2716 C<BUS_OBJERR> C<TRAP_BRKPT> C<TRAP_TRACE> C<CLD_EXITED> C<CLD_KILLED> C<CLD_DUMPED> C<CLD_TRAPPED>
2717 C<CLD_STOPPED> C<CLD_CONTINUED> C<POLL_IN> C<POLL_OUT> C<POLL_MSG> C<POLL_ERR> C<POLL_PRI>
2718 C<POLL_HUP> C<SI_USER> C<SI_QUEUE> C<SI_TIMER> C<SI_ASYNCIO> C<SI_MESGQ>
2719
2720 =back
2721
2722 =head1 STAT
2723
2724 =over 8
2725
2726 =item Constants
2727
2728 C<S_IRGRP> C<S_IROTH> C<S_IRUSR> C<S_IRWXG> C<S_IRWXO> C<S_IRWXU> C<S_ISGID> C<S_ISUID> C<S_IWGRP> C<S_IWOTH>
2729 C<S_IWUSR> C<S_IXGRP> C<S_IXOTH> C<S_IXUSR>
2730
2731 =item Macros
2732
2733 C<S_ISBLK> C<S_ISCHR> C<S_ISDIR> C<S_ISFIFO> C<S_ISREG>
2734
2735 =back
2736
2737 =head1 STDLIB
2738
2739 =over 8
2740
2741 =item Constants
2742
2743 C<EXIT_FAILURE> C<EXIT_SUCCESS> C<MB_CUR_MAX> C<RAND_MAX>
2744
2745 =back
2746
2747 =head1 STDIO
2748
2749 =over 8
2750
2751 =item Constants
2752
2753 C<BUFSIZ> C<EOF> C<FILENAME_MAX> C<L_ctermid> C<L_cuserid> C<TMP_MAX>
2754
2755 =back
2756
2757 =head1 TIME
2758
2759 =over 8
2760
2761 =item Constants
2762
2763 C<CLK_TCK> C<CLOCKS_PER_SEC>
2764
2765 =back
2766
2767 =head1 UNISTD
2768
2769 =over 8
2770
2771 =item Constants
2772
2773 C<R_OK> C<SEEK_CUR> C<SEEK_END> C<SEEK_SET> C<STDIN_FILENO> C<STDOUT_FILENO> C<STDERR_FILENO> C<W_OK> C<X_OK>
2774
2775 =back
2776
2777 =head1 WAIT
2778
2779 =over 8
2780
2781 =item Constants
2782
2783 C<WNOHANG> C<WUNTRACED>
2784
2785 =over 16
2786
2787 =item C<WNOHANG>
2788
2789 Do not suspend the calling process until a child process
2790 changes state but instead return immediately.
2791
2792 =item C<WUNTRACED>
2793
2794 Catch stopped child processes.
2795
2796 =back
2797
2798 =item Macros
2799
2800 C<WIFEXITED> C<WEXITSTATUS> C<WIFSIGNALED> C<WTERMSIG> C<WIFSTOPPED> C<WSTOPSIG>
2801
2802 =over 16
2803
2804 =item C<WIFEXITED>
2805
2806 C<WIFEXITED(${^CHILD_ERROR_NATIVE})> returns true if the child process
2807 exited normally (C<exit()> or by falling off the end of C<main()>)
2808
2809 =item C<WEXITSTATUS>
2810
2811 C<WEXITSTATUS(${^CHILD_ERROR_NATIVE})> returns the normal exit status of
2812 the child process (only meaningful if C<WIFEXITED(${^CHILD_ERROR_NATIVE})>
2813 is true)
2814
2815 =item C<WIFSIGNALED>
2816
2817 C<WIFSIGNALED(${^CHILD_ERROR_NATIVE})> returns true if the child process
2818 terminated because of a signal
2819
2820 =item C<WTERMSIG>
2821
2822 C<WTERMSIG(${^CHILD_ERROR_NATIVE})> returns the signal the child process
2823 terminated for (only meaningful if
2824 C<WIFSIGNALED(${^CHILD_ERROR_NATIVE})>
2825 is true)
2826
2827 =item C<WIFSTOPPED>
2828
2829 C<WIFSTOPPED(${^CHILD_ERROR_NATIVE})> returns true if the child process is
2830 currently stopped (can happen only if you specified the WUNTRACED flag
2831 to C<waitpid()>)
2832
2833 =item C<WSTOPSIG>
2834
2835 C<WSTOPSIG(${^CHILD_ERROR_NATIVE})> returns the signal the child process
2836 was stopped for (only meaningful if
2837 C<WIFSTOPPED(${^CHILD_ERROR_NATIVE})>
2838 is true)
2839
2840 =back
2841
2842 =back
2843
2844 =head1 WINSOCK
2845
2846 (Windows only.)
2847
2848 =over 8
2849
2850 =item Constants
2851
2852 Added in Perl v5.24:
2853
2854 C<WSAEINTR> C<WSAEBADF> C<WSAEACCES> C<WSAEFAULT> C<WSAEINVAL> C<WSAEMFILE> C<WSAEWOULDBLOCK>
2855 C<WSAEINPROGRESS> C<WSAEALREADY> C<WSAENOTSOCK> C<WSAEDESTADDRREQ> C<WSAEMSGSIZE>
2856 C<WSAEPROTOTYPE> C<WSAENOPROTOOPT> C<WSAEPROTONOSUPPORT> C<WSAESOCKTNOSUPPORT>
2857 C<WSAEOPNOTSUPP> C<WSAEPFNOSUPPORT> C<WSAEAFNOSUPPORT> C<WSAEADDRINUSE>
2858 C<WSAEADDRNOTAVAIL> C<WSAENETDOWN> C<WSAENETUNREACH> C<WSAENETRESET> C<WSAECONNABORTED>
2859 C<WSAECONNRESET> C<WSAENOBUFS> C<WSAEISCONN> C<WSAENOTCONN> C<WSAESHUTDOWN>
2860 C<WSAETOOMANYREFS> C<WSAETIMEDOUT> C<WSAECONNREFUSED> C<WSAELOOP> C<WSAENAMETOOLONG>
2861 C<WSAEHOSTDOWN> C<WSAEHOSTUNREACH> C<WSAENOTEMPTY> C<WSAEPROCLIM> C<WSAEUSERS>
2862 C<WSAEDQUOT> C<WSAESTALE> C<WSAEREMOTE> C<WSAEDISCON> C<WSAENOMORE> C<WSAECANCELLED>
2863 C<WSAEINVALIDPROCTABLE> C<WSAEINVALIDPROVIDER> C<WSAEPROVIDERFAILEDINIT>
2864 C<WSAEREFUSED>
2865
2866 =back
2867