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