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