You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1984 lines
51 KiB
1984 lines
51 KiB
=head1 NAME
|
|
|
|
POSIX - Perl interface to IEEE Std 1003.1
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use POSIX;
|
|
use POSIX qw(setsid);
|
|
use POSIX qw(:errno_h :fcntl_h);
|
|
|
|
printf "EINTR is %d\n", EINTR;
|
|
|
|
$sess_id = POSIX::setsid();
|
|
|
|
$fd = POSIX::open($path, O_CREAT|O_EXCL|O_WRONLY, 0644);
|
|
# note: that's a filedescriptor, *NOT* a filehandle
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
The POSIX module permits you to access all (or nearly all) the standard
|
|
POSIX 1003.1 identifiers. Many of these identifiers have been given Perl-ish
|
|
interfaces. Things which are C<#defines> in C, like EINTR or O_NDELAY, are
|
|
automatically exported into your namespace. All functions are only exported
|
|
if you ask for them explicitly. Most likely people will prefer to use the
|
|
fully-qualified function names.
|
|
|
|
This document gives a condensed list of the features available in the POSIX
|
|
module. Consult your operating system's manpages for general information on
|
|
most features. Consult L<perlfunc> for functions which are noted as being
|
|
identical to Perl's builtin functions.
|
|
|
|
The first section describes POSIX functions from the 1003.1 specification.
|
|
The second section describes some classes for signal objects, TTY objects,
|
|
and other miscellaneous objects. The remaining sections list various
|
|
constants and macros in an organization which roughly follows IEEE Std
|
|
1003.1b-1993.
|
|
|
|
=head1 NOTE
|
|
|
|
The POSIX module is probably the most complex Perl module supplied with
|
|
the standard distribution. It incorporates autoloading, namespace games,
|
|
and dynamic loading of code that's in Perl, C, or both. It's a great
|
|
source of wisdom.
|
|
|
|
=head1 CAVEATS
|
|
|
|
A few functions are not implemented because they are C specific. If you
|
|
attempt to call these, they will print a message telling you that they
|
|
aren't implemented, and suggest using the Perl equivalent should one
|
|
exist. For example, trying to access the setjmp() call will elicit the
|
|
message "setjmp() is C-specific: use eval {} instead".
|
|
|
|
Furthermore, some evil vendors will claim 1003.1 compliance, but in fact
|
|
are not so: they will not pass the PCTS (POSIX Compliance Test Suites).
|
|
For example, one vendor may not define EDEADLK, or the semantics of the
|
|
errno values set by open(2) might not be quite right. Perl does not
|
|
attempt to verify POSIX compliance. That means you can currently
|
|
successfully say "use POSIX", and then later in your program you find
|
|
that your vendor has been lax and there's no usable ICANON macro after
|
|
all. This could be construed to be a bug.
|
|
|
|
=head1 FUNCTIONS
|
|
|
|
=over 8
|
|
|
|
=item _exit
|
|
|
|
This is identical to the C function C<_exit()>. It exits the program
|
|
immediately which means among other things buffered I/O is B<not> flushed.
|
|
|
|
=item abort
|
|
|
|
This is identical to the C function C<abort()>. It terminates the
|
|
process with a C<SIGABRT> signal unless caught by a signal handler or
|
|
if the handler does not return normally (it e.g. does a C<longjmp>).
|
|
|
|
=item abs
|
|
|
|
This is identical to Perl's builtin C<abs()> function, returning
|
|
the absolute value of its numerical argument.
|
|
|
|
=item access
|
|
|
|
Determines the accessibility of a file.
|
|
|
|
if( POSIX::access( "/", &POSIX::R_OK ) ){
|
|
print "have read permission\n";
|
|
}
|
|
|
|
Returns C<undef> on failure. Note: do not use C<access()> for
|
|
security purposes. Between the C<access()> call and the operation
|
|
you are preparing for the permissions might change: a classic
|
|
I<race condition>.
|
|
|
|
=item acos
|
|
|
|
This is identical to the C function C<acos()>, returning
|
|
the arcus cosine of its numerical argument. See also L<Math::Trig>.
|
|
|
|
=item alarm
|
|
|
|
This is identical to Perl's builtin C<alarm()> function,
|
|
either for arming or disarming the C<SIGARLM> timer.
|
|
|
|
=item asctime
|
|
|
|
This is identical to the C function C<asctime()>. It returns
|
|
a string of the form
|
|
|
|
"Fri Jun 2 18:22:13 2000\n\0"
|
|
|
|
and it is called thusly
|
|
|
|
$asctime = asctime($sec, $min, $hour, $mday, $mon, $year,
|
|
$wday, $yday, $isdst);
|
|
|
|
The C<$mon> is zero-based: January equals C<0>. The C<$year> is
|
|
1900-based: 2001 equals C<101>. The C<$wday>, C<$yday>, and C<$isdst>
|
|
default to zero (and the first two are usually ignored anyway).
|
|
|
|
=item asin
|
|
|
|
This is identical to the C function C<asin()>, returning
|
|
the arcus sine of its numerical argument. See also L<Math::Trig>.
|
|
|
|
=item assert
|
|
|
|
Unimplemented, but you can use L<perlfunc/die> and the L<Carp> module
|
|
to achieve similar things.
|
|
|
|
=item atan
|
|
|
|
This is identical to the C function C<atan()>, returning the
|
|
arcus tangent of its numerical argument. See also L<Math::Trig>.
|
|
|
|
=item atan2
|
|
|
|
This is identical to Perl's builtin C<atan2()> function, returning
|
|
the arcus tangent defined by its two numerical arguments, the I<y>
|
|
coordinate and the I<x> coordinate. See also L<Math::Trig>.
|
|
|
|
=item atexit
|
|
|
|
atexit() is C-specific: use C<END {}> instead, see L<perlsub>.
|
|
|
|
=item atof
|
|
|
|
atof() is C-specific. Perl converts strings to numbers transparently.
|
|
If you need to force a scalar to a number, add a zero to it.
|
|
|
|
=item atoi
|
|
|
|
atoi() is C-specific. Perl converts strings to numbers transparently.
|
|
If you need to force a scalar to a number, add a zero to it.
|
|
If you need to have just the integer part, see L<perlfunc/int>.
|
|
|
|
=item atol
|
|
|
|
atol() is C-specific. Perl converts strings to numbers transparently.
|
|
If you need to force a scalar to a number, add a zero to it.
|
|
If you need to have just the integer part, see L<perlfunc/int>.
|
|
|
|
=item bsearch
|
|
|
|
bsearch() not supplied. For doing binary search on wordlists,
|
|
see L<Search::Dict>.
|
|
|
|
=item calloc
|
|
|
|
calloc() is C-specific. Perl does memory management transparently.
|
|
|
|
=item ceil
|
|
|
|
This is identical to the C function C<ceil()>, returning the smallest
|
|
integer value greater than or equal to the given numerical argument.
|
|
|
|
=item chdir
|
|
|
|
This is identical to Perl's builtin C<chdir()> function, allowing
|
|
one to change the working (default) directory, see L<perlfunc/chdir>.
|
|
|
|
=item chmod
|
|
|
|
This is identical to Perl's builtin C<chmod()> function, allowing
|
|
one to change file and directory permissions, see L<perlfunc/chmod>.
|
|
|
|
=item chown
|
|
|
|
This is identical to Perl's builtin C<chown()> function, allowing one
|
|
to change file and directory owners and groups, see L<perlfunc/chown>.
|
|
|
|
=item clearerr
|
|
|
|
Use the method L<IO::Handle::clearerr()> instead, to reset the error
|
|
state (if any) and EOF state (if any) of the given stream.
|
|
|
|
=item clock
|
|
|
|
This is identical to the C function C<clock()>, returning the
|
|
amount of spent processor time in microseconds.
|
|
|
|
=item close
|
|
|
|
Close the file. This uses file descriptors such as those obtained by calling
|
|
C<POSIX::open>.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
|
|
POSIX::close( $fd );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
See also L<perlfunc/close>.
|
|
|
|
=item closedir
|
|
|
|
This is identical to Perl's builtin C<closedir()> function for closing
|
|
a directory handle, see L<perlfunc/closedir>.
|
|
|
|
=item cos
|
|
|
|
This is identical to Perl's builtin C<cos()> function, for returning
|
|
the cosine of its numerical argument, see L<perlfunc/cos>.
|
|
See also L<Math::Trig>.
|
|
|
|
=item cosh
|
|
|
|
This is identical to the C function C<cosh()>, for returning
|
|
the hyperbolic cosine of its numeric argument. See also L<Math::Trig>.
|
|
|
|
=item creat
|
|
|
|
Create a new file. This returns a file descriptor like the ones returned by
|
|
C<POSIX::open>. Use C<POSIX::close> to close the file.
|
|
|
|
$fd = POSIX::creat( "foo", 0611 );
|
|
POSIX::close( $fd );
|
|
|
|
See also L<perlfunc/sysopen> and its C<O_CREAT> flag.
|
|
|
|
=item ctermid
|
|
|
|
Generates the path name for the controlling terminal.
|
|
|
|
$path = POSIX::ctermid();
|
|
|
|
=item ctime
|
|
|
|
This is identical to the C function C<ctime()> and equivalent
|
|
to C<asctime(localtime(...))>, see L</asctime> and L</localtime>.
|
|
|
|
=item cuserid
|
|
|
|
Get the login name of the owner of the current process.
|
|
|
|
$name = POSIX::cuserid();
|
|
|
|
=item difftime
|
|
|
|
This is identical to the C function C<difftime()>, for returning
|
|
the time difference (in seconds) between two times (as returned
|
|
by C<time()>), see L</time>.
|
|
|
|
=item div
|
|
|
|
div() is C-specific, use L<perlfunc/int> on the usual C</> division and
|
|
the modulus C<%>.
|
|
|
|
=item dup
|
|
|
|
This is similar to the C function C<dup()>, for duplicating a file
|
|
descriptor.
|
|
|
|
This uses file descriptors such as those obtained by calling
|
|
C<POSIX::open>.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item dup2
|
|
|
|
This is similar to the C function C<dup2()>, for duplicating a file
|
|
descriptor to an another known file descriptor.
|
|
|
|
This uses file descriptors such as those obtained by calling
|
|
C<POSIX::open>.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item errno
|
|
|
|
Returns the value of errno.
|
|
|
|
$errno = POSIX::errno();
|
|
|
|
This identical to the numerical values of the C<$!>, see L<perlvar/$ERRNO>.
|
|
|
|
=item execl
|
|
|
|
execl() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item execle
|
|
|
|
execle() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item execlp
|
|
|
|
execlp() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item execv
|
|
|
|
execv() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item execve
|
|
|
|
execve() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item execvp
|
|
|
|
execvp() is C-specific, see L<perlfunc/exec>.
|
|
|
|
=item exit
|
|
|
|
This is identical to Perl's builtin C<exit()> function for exiting the
|
|
program, see L<perlfunc/exit>.
|
|
|
|
=item exp
|
|
|
|
This is identical to Perl's builtin C<exp()> function for
|
|
returning the exponent (I<e>-based) of the numerical argument,
|
|
see L<perlfunc/exp>.
|
|
|
|
=item fabs
|
|
|
|
This is identical to Perl's builtin C<abs()> function for returning
|
|
the absolute value of the numerical argument, see L<perlfunc/abs>.
|
|
|
|
=item fclose
|
|
|
|
Use method C<IO::Handle::close()> instead, or see L<perlfunc/close>.
|
|
|
|
=item fcntl
|
|
|
|
This is identical to Perl's builtin C<fcntl()> function,
|
|
see L<perlfunc/fcntl>.
|
|
|
|
=item fdopen
|
|
|
|
Use method C<IO::Handle::new_from_fd()> instead, or see L<perlfunc/open>.
|
|
|
|
=item feof
|
|
|
|
Use method C<IO::Handle::eof()> instead, or see L<perlfunc/eof>.
|
|
|
|
=item ferror
|
|
|
|
Use method C<IO::Handle::error()> instead.
|
|
|
|
=item fflush
|
|
|
|
Use method C<IO::Handle::flush()> instead.
|
|
See also L<perlvar/$OUTPUT_AUTOFLUSH>.
|
|
|
|
=item fgetc
|
|
|
|
Use method C<IO::Handle::getc()> instead, or see L<perlfunc/read>.
|
|
|
|
=item fgetpos
|
|
|
|
Use method C<IO::Seekable::getpos()> instead, or see L<L/seek>.
|
|
|
|
=item fgets
|
|
|
|
Use method C<IO::Handle::gets()> instead. Similar to E<lt>E<gt>, also known
|
|
as L<perlfunc/readline>.
|
|
|
|
=item fileno
|
|
|
|
Use method C<IO::Handle::fileno()> instead, or see L<perlfunc/fileno>.
|
|
|
|
=item floor
|
|
|
|
This is identical to the C function C<floor()>, returning the largest
|
|
integer value less than or equal to the numerical argument.
|
|
|
|
=item fmod
|
|
|
|
This is identical to the C function C<fmod()>.
|
|
|
|
$r = modf($x, $y);
|
|
|
|
It returns the remainder C<$r = $x - $n*$y>, where C<$n = trunc($x/$y)>.
|
|
The C<$r> has the same sign as C<$x> and magnitude (absolute value)
|
|
less than the magnitude of C<$y>.
|
|
|
|
=item fopen
|
|
|
|
Use method C<IO::File::open()> instead, or see L<perlfunc/open>.
|
|
|
|
=item fork
|
|
|
|
This is identical to Perl's builtin C<fork()> function
|
|
for duplicating the current process, see L<perlfunc/fork>
|
|
and L<perlfork> if you are in Windows.
|
|
|
|
=item fpathconf
|
|
|
|
Retrieves the value of a configurable limit on a file or directory. This
|
|
uses file descriptors such as those obtained by calling C<POSIX::open>.
|
|
|
|
The following will determine the maximum length of the longest allowable
|
|
pathname on the filesystem which holds C</tmp/foo>.
|
|
|
|
$fd = POSIX::open( "/tmp/foo", &POSIX::O_RDONLY );
|
|
$path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item fprintf
|
|
|
|
fprintf() is C-specific, see L<perlfunc/printf> instead.
|
|
|
|
=item fputc
|
|
|
|
fputc() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item fputs
|
|
|
|
fputs() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item fread
|
|
|
|
fread() is C-specific, see L<perlfunc/read> instead.
|
|
|
|
=item free
|
|
|
|
free() is C-specific. Perl does memory management transparently.
|
|
|
|
=item freopen
|
|
|
|
freopen() is C-specific, see L<perlfunc/open> instead.
|
|
|
|
=item frexp
|
|
|
|
Return the mantissa and exponent of a floating-point number.
|
|
|
|
($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
|
|
|
|
=item fscanf
|
|
|
|
fscanf() is C-specific, use E<lt>E<gt> and regular expressions instead.
|
|
|
|
=item fseek
|
|
|
|
Use method C<IO::Seekable::seek()> instead, or see L<perlfunc/seek>.
|
|
|
|
=item fsetpos
|
|
|
|
Use method C<IO::Seekable::setpos()> instead, or seek L<perlfunc/seek>.
|
|
|
|
=item fstat
|
|
|
|
Get file status. This uses file descriptors such as those obtained by
|
|
calling C<POSIX::open>. The data returned is identical to the data from
|
|
Perl's builtin C<stat> function.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
|
|
@stats = POSIX::fstat( $fd );
|
|
|
|
=item ftell
|
|
|
|
Use method C<IO::Seekable::tell()> instead, or see L<perlfunc/tell>.
|
|
|
|
=item fwrite
|
|
|
|
fwrite() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item getc
|
|
|
|
This is identical to Perl's builtin C<getc()> function,
|
|
see L<perlfunc/getc>.
|
|
|
|
=item getchar
|
|
|
|
Returns one character from STDIN. Identical to Perl's C<getc()>,
|
|
see L<perlfunc/getc>.
|
|
|
|
=item getcwd
|
|
|
|
Returns the name of the current working directory.
|
|
See also L<Cwd>.
|
|
|
|
=item getegid
|
|
|
|
Returns the effective group identifier. Similar to Perl' s builtin
|
|
variable C<$(>, see L<perlvar/$EGID>.
|
|
|
|
=item getenv
|
|
|
|
Returns the value of the specified enironment variable.
|
|
The same information is available through the C<%ENV> array.
|
|
|
|
=item geteuid
|
|
|
|
Returns the effective user identifier. Identical to Perl's builtin C<$E<gt>>
|
|
variable, see L<perlvar/$EUID>.
|
|
|
|
=item getgid
|
|
|
|
Returns the user's real group identifier. Similar to Perl's builtin
|
|
variable C<$)>, see L<perlvar/$GID>.
|
|
|
|
=item getgrgid
|
|
|
|
This is identical to Perl's builtin C<getgrgid()> function for
|
|
returning group entries by group identifiers, see
|
|
L<perlfunc/getgrgid>.
|
|
|
|
=item getgrnam
|
|
|
|
This is identical to Perl's builtin C<getgrnam()> function for
|
|
returning group entries by group names, see L<perlfunc/getgrnam>.
|
|
|
|
=item getgroups
|
|
|
|
Returns the ids of the user's supplementary groups. Similar to Perl's
|
|
builtin variable C<$)>, see L<perlvar/$GID>.
|
|
|
|
=item getlogin
|
|
|
|
This is identical to Perl's builtin C<getlogin()> function for
|
|
returning the user name associated with the current session, see
|
|
L<perlfunc/getlogin>.
|
|
|
|
=item getpgrp
|
|
|
|
This is identical to Perl's builtin C<getpgrp()> function for
|
|
returning the prcess group identifier of the current process, see
|
|
L<perlfunc/getpgrp>.
|
|
|
|
=item getpid
|
|
|
|
Returns the process identifier. Identical to Perl's builtin
|
|
variable C<$$>, see L<perlvar/$PID>.
|
|
|
|
=item getppid
|
|
|
|
This is identical to Perl's builtin C<getppid()> function for
|
|
returning the process identifier of the parent process of the current
|
|
process , see L<perlfunc/getppid>.
|
|
|
|
=item getpwnam
|
|
|
|
This is identical to Perl's builtin C<getpwnam()> function for
|
|
returning user entries by user names, see L<perlfunc/getpwnam>.
|
|
|
|
=item getpwuid
|
|
|
|
This is identical to Perl's builtin C<getpwuid()> function for
|
|
returning user entries by user identifiers, see L<perlfunc/getpwuid>.
|
|
|
|
=item gets
|
|
|
|
Returns one line from C<STDIN>, similar to E<lt>E<gt>, also known
|
|
as the C<readline()> function, see L<perlfunc/readline>.
|
|
|
|
B<NOTE>: if you have C programs that still use C<gets()>, be very
|
|
afraid. The C<gets()> function is a source of endless grief because
|
|
it has no buffer overrun checks. It should B<never> be used. The
|
|
C<fgets()> function should be preferred instead.
|
|
|
|
=item getuid
|
|
|
|
Returns the user's identifier. Identical to Perl's builtin C<$E<lt>> variable,
|
|
see L<perlvar/$UID>.
|
|
|
|
=item gmtime
|
|
|
|
This is identical to Perl's builtin C<gmtime()> function for
|
|
converting seconds since the epoch to a date in Greenwich Mean Time,
|
|
see L<perlfunc/gmtime>.
|
|
|
|
=item isalnum
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isalnum:]]/> construct instead, or possibly the C</\w/> construct.
|
|
|
|
=item isalpha
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isalpha:]]/> construct instead.
|
|
|
|
=item isatty
|
|
|
|
Returns a boolean indicating whether the specified filehandle is connected
|
|
to a tty. Similar to the C<-t> operator, see L<perlfunc/-X>.
|
|
|
|
=item iscntrl
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:iscntrl:]]/> construct instead.
|
|
|
|
=item isdigit
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isdigit:]]/> construct instead, or the C</\d/> construct.
|
|
|
|
=item isgraph
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isgraph:]]/> construct instead.
|
|
|
|
=item islower
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:islower:]]/> construct instead. Do B<not> use C</a-z/>.
|
|
|
|
=item isprint
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isprint:]]/> construct instead.
|
|
|
|
=item ispunct
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:ispunct:]]/> construct instead.
|
|
|
|
=item isspace
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isspace:]]/> construct instead, or the C</\s/> construct.
|
|
|
|
=item isupper
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isupper:]]/> construct instead. Do B<not> use C</A-Z/>.
|
|
|
|
=item isxdigit
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using regular expressions and the
|
|
C</[[:isxdigit:]]/> construct instead, or simply C</[0-9a-f]/i>.
|
|
|
|
=item kill
|
|
|
|
This is identical to Perl's builtin C<kill()> function for sending
|
|
signals to processes (often to terminate them), see L<perlfunc/kill>.
|
|
|
|
=item labs
|
|
|
|
(For returning absolute values of long integers.)
|
|
labs() is C-specific, see L<perlfunc/abs> instead.
|
|
|
|
=item ldexp
|
|
|
|
This is identical to the C function C<ldexp()>
|
|
for multiplying floating point numbers with powers of two.
|
|
|
|
$x_quadrupled = POSIX::ldexp($x, 2);
|
|
|
|
=item ldiv
|
|
|
|
(For computing dividends of long integers.)
|
|
ldiv() is C-specific, use C</> and C<int()> instead.
|
|
|
|
=item link
|
|
|
|
This is identical to Perl's builtin C<link()> function
|
|
for creating hard links into files, see L<perlfunc/link>.
|
|
|
|
=item localeconv
|
|
|
|
Get numeric formatting information. Returns a reference to a hash
|
|
containing the current locale formatting values.
|
|
|
|
Here is how to query the database for the B<de> (Deutsch or German) locale.
|
|
|
|
$loc = POSIX::setlocale( &POSIX::LC_ALL, "de" );
|
|
print "Locale = $loc\n";
|
|
$lconv = POSIX::localeconv();
|
|
print "decimal_point = ", $lconv->{decimal_point}, "\n";
|
|
print "thousands_sep = ", $lconv->{thousands_sep}, "\n";
|
|
print "grouping = ", $lconv->{grouping}, "\n";
|
|
print "int_curr_symbol = ", $lconv->{int_curr_symbol}, "\n";
|
|
print "currency_symbol = ", $lconv->{currency_symbol}, "\n";
|
|
print "mon_decimal_point = ", $lconv->{mon_decimal_point}, "\n";
|
|
print "mon_thousands_sep = ", $lconv->{mon_thousands_sep}, "\n";
|
|
print "mon_grouping = ", $lconv->{mon_grouping}, "\n";
|
|
print "positive_sign = ", $lconv->{positive_sign}, "\n";
|
|
print "negative_sign = ", $lconv->{negative_sign}, "\n";
|
|
print "int_frac_digits = ", $lconv->{int_frac_digits}, "\n";
|
|
print "frac_digits = ", $lconv->{frac_digits}, "\n";
|
|
print "p_cs_precedes = ", $lconv->{p_cs_precedes}, "\n";
|
|
print "p_sep_by_space = ", $lconv->{p_sep_by_space}, "\n";
|
|
print "n_cs_precedes = ", $lconv->{n_cs_precedes}, "\n";
|
|
print "n_sep_by_space = ", $lconv->{n_sep_by_space}, "\n";
|
|
print "p_sign_posn = ", $lconv->{p_sign_posn}, "\n";
|
|
print "n_sign_posn = ", $lconv->{n_sign_posn}, "\n";
|
|
|
|
=item localtime
|
|
|
|
This is identical to Perl's builtin C<localtime()> function for
|
|
converting seconds since the epoch to a date see L<perlfunc/localtime>.
|
|
|
|
=item log
|
|
|
|
This is identical to Perl's builtin C<log()> function,
|
|
returning the natural (I<e>-based) logarithm of the numerical argument,
|
|
see L<perlfunc/log>.
|
|
|
|
=item log10
|
|
|
|
This is identical to the C function C<log10()>,
|
|
returning the 10-base logarithm of the numerical argument.
|
|
You can also use
|
|
|
|
sub log10 { log($_[0]) / log(10) }
|
|
|
|
or
|
|
|
|
sub log10 { log($_[0]) / 2.30258509299405 }
|
|
|
|
or
|
|
|
|
sub log10 { log($_[0]) * 0.434294481903252 }
|
|
|
|
=item longjmp
|
|
|
|
longjmp() is C-specific: use L<perlfunc/die> instead.
|
|
|
|
=item lseek
|
|
|
|
Move the file's read/write position. This uses file descriptors such as
|
|
those obtained by calling C<POSIX::open>.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
|
|
$off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item malloc
|
|
|
|
malloc() is C-specific. Perl does memory management transparently.
|
|
|
|
=item mblen
|
|
|
|
This is identical to the C function C<mblen()>.
|
|
Perl does not have any support for the wide and multibyte
|
|
characters of the C standards, so this might be a rather
|
|
useless function.
|
|
|
|
=item mbstowcs
|
|
|
|
This is identical to the C function C<mbstowcs()>.
|
|
Perl does not have any support for the wide and multibyte
|
|
characters of the C standards, so this might be a rather
|
|
useless function.
|
|
|
|
=item mbtowc
|
|
|
|
This is identical to the C function C<mbtowc()>.
|
|
Perl does not have any support for the wide and multibyte
|
|
characters of the C standards, so this might be a rather
|
|
useless function.
|
|
|
|
=item memchr
|
|
|
|
memchr() is C-specific, see L<perlfunc/index> instead.
|
|
|
|
=item memcmp
|
|
|
|
memcmp() is C-specific, use C<eq> instead, see L<perlop>.
|
|
|
|
=item memcpy
|
|
|
|
memcpy() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
|
|
|
|
=item memmove
|
|
|
|
memmove() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>.
|
|
|
|
=item memset
|
|
|
|
memset() is C-specific, use C<x> instead, see L<perlop>.
|
|
|
|
=item mkdir
|
|
|
|
This is identical to Perl's builtin C<mkdir()> function
|
|
for creating directories, see L<perlfunc/mkdir>.
|
|
|
|
=item mkfifo
|
|
|
|
This is similar to the C function C<mkfifo()> for creating
|
|
FIFO special files.
|
|
|
|
if (mkfifo($path, $mode)) { ....
|
|
|
|
Returns C<undef> on failure. The C<$mode> is similar to the
|
|
mode of C<mkdir()>, see L<perlfunc/mkdir>.
|
|
|
|
=item mktime
|
|
|
|
Convert date/time info to a calendar time.
|
|
|
|
Synopsis:
|
|
|
|
mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
|
|
|
|
The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
|
|
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
|
|
year (C<year>) is given in years since 1900. I.e. The year 1995 is 95; the
|
|
year 2001 is 101. Consult your system's C<mktime()> manpage for details
|
|
about these and the other arguments.
|
|
|
|
Calendar time for December 12, 1995, at 10:30 am.
|
|
|
|
$time_t = POSIX::mktime( 0, 30, 10, 12, 11, 95 );
|
|
print "Date = ", POSIX::ctime($time_t);
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item modf
|
|
|
|
Return the integral and fractional parts of a floating-point number.
|
|
|
|
($fractional, $integral) = POSIX::modf( 3.14 );
|
|
|
|
=item nice
|
|
|
|
This is similar to the C function C<nice()>, for changing
|
|
the scheduling preference of the current process. Positive
|
|
arguments mean more polite process, negative values more
|
|
needy process. Normal user processes can only be more polite.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item offsetof
|
|
|
|
offsetof() is C-specific, you probably want to see L<perlfunc/pack> instead.
|
|
|
|
=item open
|
|
|
|
Open a file for reading for writing. This returns file descriptors, not
|
|
Perl filehandles. Use C<POSIX::close> to close the file.
|
|
|
|
Open a file read-only with mode 0666.
|
|
|
|
$fd = POSIX::open( "foo" );
|
|
|
|
Open a file for read and write.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_RDWR );
|
|
|
|
Open a file for write, with truncation.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_WRONLY | &POSIX::O_TRUNC );
|
|
|
|
Create a new file with mode 0640. Set up the file for writing.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
See also L<perlfunc/sysopen>.
|
|
|
|
=item opendir
|
|
|
|
Open a directory for reading.
|
|
|
|
$dir = POSIX::opendir( "/tmp" );
|
|
@files = POSIX::readdir( $dir );
|
|
POSIX::closedir( $dir );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item pathconf
|
|
|
|
Retrieves the value of a configurable limit on a file or directory.
|
|
|
|
The following will determine the maximum length of the longest allowable
|
|
pathname on the filesystem which holds C</tmp>.
|
|
|
|
$path_max = POSIX::pathconf( "/tmp", &POSIX::_PC_PATH_MAX );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item pause
|
|
|
|
This is similar to the C function C<pause()>, which suspends
|
|
the execution of the current process until a signal is received.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item perror
|
|
|
|
This is identical to the C function C<perror()>, which outputs to the
|
|
standard error stream the specified message followed by ": " and the
|
|
current error string. Use the C<warn()> function and the C<$!>
|
|
variable instead, see L<perlfunc/warn> and L<perlvar/$ERRNO>.
|
|
|
|
=item pipe
|
|
|
|
Create an interprocess channel. This returns file descriptors like those
|
|
returned by C<POSIX::open>.
|
|
|
|
($fd0, $fd1) = POSIX::pipe();
|
|
POSIX::write( $fd0, "hello", 5 );
|
|
POSIX::read( $fd1, $buf, 5 );
|
|
|
|
See also L<perlfunc/pipe>.
|
|
|
|
=item pow
|
|
|
|
Computes C<$x> raised to the power C<$exponent>.
|
|
|
|
$ret = POSIX::pow( $x, $exponent );
|
|
|
|
You can also use the C<**> operator, see L<perlop>.
|
|
|
|
=item printf
|
|
|
|
Formats and prints the specified arguments to STDOUT.
|
|
See also L<perlfunc/printf>.
|
|
|
|
=item putc
|
|
|
|
putc() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item putchar
|
|
|
|
putchar() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item puts
|
|
|
|
puts() is C-specific, see L<perlfunc/print> instead.
|
|
|
|
=item qsort
|
|
|
|
qsort() is C-specific, see L<perlfunc/sort> instead.
|
|
|
|
=item raise
|
|
|
|
Sends the specified signal to the current process.
|
|
See also L<perlfunc/kill> and the C<$$> in L<perlvar/$PID>.
|
|
|
|
=item rand
|
|
|
|
C<rand()> is non-portable, see L<perlfunc/rand> instead.
|
|
|
|
=item read
|
|
|
|
Read from a file. This uses file descriptors such as those obtained by
|
|
calling C<POSIX::open>. If the buffer C<$buf> is not large enough for the
|
|
read then Perl will extend it to make room for the request.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
|
|
$bytes = POSIX::read( $fd, $buf, 3 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
See also L<perlfunc/sysread>.
|
|
|
|
=item readdir
|
|
|
|
This is identical to Perl's builtin C<readdir()> function
|
|
for reading directory entries, see L<perlfunc/readdir>.
|
|
|
|
=item realloc
|
|
|
|
realloc() is C-specific. Perl does memory management transparently.
|
|
|
|
=item remove
|
|
|
|
This is identical to Perl's builtin C<unlink()> function
|
|
for removing files, see L<perlfunc/unlink>.
|
|
|
|
=item rename
|
|
|
|
This is identical to Perl's builtin C<rename()> function
|
|
for renaming files, see L<perlfunc/rename>.
|
|
|
|
=item rewind
|
|
|
|
Seeks to the beginning of the file.
|
|
|
|
=item rewinddir
|
|
|
|
This is identical to Perl's builtin C<rewinddir()> function for
|
|
rewinding directory entry streams, see L<perlfunc/rewinddir>.
|
|
|
|
=item rmdir
|
|
|
|
This is identical to Perl's builtin C<rmdir()> function
|
|
for removing (empty) directories, see L<perlfunc/rmdir>.
|
|
|
|
=item scanf
|
|
|
|
scanf() is C-specific, use E<lt>E<gt> and regular expressions instead,
|
|
see L<perlre>.
|
|
|
|
=item setgid
|
|
|
|
Sets the real group identifier for this process.
|
|
Identical to assigning a value to the Perl's builtin C<$)> variable,
|
|
see L<perlvar/$UID>.
|
|
|
|
=item setjmp
|
|
|
|
C<setjmp()> is C-specific: use C<eval {}> instead,
|
|
see L<perlfunc/eval>.
|
|
|
|
=item setlocale
|
|
|
|
Modifies and queries program's locale. The following examples assume
|
|
|
|
use POSIX qw(setlocale LC_ALL LC_CTYPE);
|
|
|
|
has been issued.
|
|
|
|
The following will set the traditional UNIX system locale behavior
|
|
(the second argument C<"C">).
|
|
|
|
$loc = setlocale( LC_ALL, "C" );
|
|
|
|
The following will query the current LC_CTYPE category. (No second
|
|
argument means 'query'.)
|
|
|
|
$loc = setlocale( LC_CTYPE );
|
|
|
|
The following will set the LC_CTYPE behaviour according to the locale
|
|
environment variables (the second argument C<"">).
|
|
Please see your systems L<setlocale(3)> documentation for the locale
|
|
environment variables' meaning or consult L<perllocale>.
|
|
|
|
$loc = setlocale( LC_CTYPE, "" );
|
|
|
|
The following will set the LC_COLLATE behaviour to Argentinian
|
|
Spanish. B<NOTE>: The naming and availability of locales depends on
|
|
your operating system. Please consult L<perllocale> for how to find
|
|
out which locales are available in your system.
|
|
|
|
$loc = setlocale( LC_ALL, "es_AR.ISO8859-1" );
|
|
|
|
=item setpgid
|
|
|
|
This is similar to the C function C<setpgid()> for
|
|
setting the process group identifier of the current process.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item setsid
|
|
|
|
This is identical to the C function C<setsid()> for
|
|
setting the session identifier of the current process.
|
|
|
|
=item setuid
|
|
|
|
Sets the real user identifier for this process.
|
|
Identical to assigning a value to the Perl's builtin C<$E<lt>> variable,
|
|
see L<perlvar/$UID>.
|
|
|
|
=item sigaction
|
|
|
|
Detailed signal management. This uses C<POSIX::SigAction> objects for the
|
|
C<action> and C<oldaction> arguments. Consult your system's C<sigaction>
|
|
manpage for details.
|
|
|
|
Synopsis:
|
|
|
|
sigaction(sig, action, oldaction = 0)
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item siglongjmp
|
|
|
|
siglongjmp() is C-specific: use L<perlfunc/die> instead.
|
|
|
|
=item sigpending
|
|
|
|
Examine signals that are blocked and pending. This uses C<POSIX::SigSet>
|
|
objects for the C<sigset> argument. Consult your system's C<sigpending>
|
|
manpage for details.
|
|
|
|
Synopsis:
|
|
|
|
sigpending(sigset)
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item sigprocmask
|
|
|
|
Change and/or examine calling process's signal mask. This uses
|
|
C<POSIX::SigSet> objects for the C<sigset> and C<oldsigset> arguments.
|
|
Consult your system's C<sigprocmask> manpage for details.
|
|
|
|
Synopsis:
|
|
|
|
sigprocmask(how, sigset, oldsigset = 0)
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item sigsetjmp
|
|
|
|
C<sigsetjmp()> is C-specific: use C<eval {}> instead,
|
|
see L<perlfunc/eval>.
|
|
|
|
=item sigsuspend
|
|
|
|
Install a signal mask and suspend process until signal arrives. This uses
|
|
C<POSIX::SigSet> objects for the C<signal_mask> argument. Consult your
|
|
system's C<sigsuspend> manpage for details.
|
|
|
|
Synopsis:
|
|
|
|
sigsuspend(signal_mask)
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item sin
|
|
|
|
This is identical to Perl's builtin C<sin()> function
|
|
for returning the sine of the numerical argument,
|
|
see L<perlfunc/sin>. See also L<Math::Trig>.
|
|
|
|
=item sinh
|
|
|
|
This is identical to the C function C<sinh()>
|
|
for returning the hyperbolic sine of the numerical argument.
|
|
See also L<Math::Trig>.
|
|
|
|
=item sleep
|
|
|
|
This is identical to Perl's builtin C<sleep()> function
|
|
for suspending the execution of the current for process
|
|
for certain number of seconds, see L<perlfunc/sleep>.
|
|
|
|
=item sprintf
|
|
|
|
This is similar to Perl's builtin C<sprintf()> function
|
|
for returning a string that has the arguments formatted as requested,
|
|
see L<perlfunc/sprintf>.
|
|
|
|
=item sqrt
|
|
|
|
This is identical to Perl's builtin C<sqrt()> function.
|
|
for returning the square root of the numerical argument,
|
|
see L<perlfunc/sqrt>.
|
|
|
|
=item srand
|
|
|
|
Give a seed the pseudorandom number generator, see L<perlfunc/srand>.
|
|
|
|
=item sscanf
|
|
|
|
sscanf() is C-specific, use regular expressions instead,
|
|
see L<perlre>.
|
|
|
|
=item stat
|
|
|
|
This is identical to Perl's builtin C<stat()> function
|
|
for retutning information about files and directories.
|
|
|
|
=item strcat
|
|
|
|
strcat() is C-specific, use C<.=> instead, see L<perlop>.
|
|
|
|
=item strchr
|
|
|
|
strchr() is C-specific, see L<perlfunc/index> instead.
|
|
|
|
=item strcmp
|
|
|
|
strcmp() is C-specific, use C<eq> or C<cmp> instead, see L<perlop>.
|
|
|
|
=item strcoll
|
|
|
|
This is identical to the C function C<strcoll()>
|
|
for collating (comparing) strings transformed using
|
|
the C<strxfrm()> function. Not really needed since
|
|
Perl can do this transparently, see L<perllocale>.
|
|
|
|
=item strcpy
|
|
|
|
strcpy() is C-specific, use C<=> instead, see L<perlop>.
|
|
|
|
=item strcspn
|
|
|
|
strcspn() is C-specific, use regular expressions instead,
|
|
see L<perlre>.
|
|
|
|
=item strerror
|
|
|
|
Returns the error string for the specified errno.
|
|
Identical to the string form of the C<$!>, see L<perlvar/$ERRNO>.
|
|
|
|
=item strftime
|
|
|
|
Convert date and time information to string. Returns the string.
|
|
|
|
Synopsis:
|
|
|
|
strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
|
|
|
|
The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero.
|
|
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
|
|
year (C<year>) is given in years since 1900. I.e., the year 1995 is 95; the
|
|
year 2001 is 101. Consult your system's C<strftime()> manpage for details
|
|
about these and the other arguments.
|
|
If you want your code to be portable, your format (C<fmt>) argument
|
|
should use only the conversion specifiers defined by the ANSI C
|
|
standard. These are C<aAbBcdHIjmMpSUwWxXyYZ%>.
|
|
The given arguments are made consistent
|
|
as though by calling C<mktime()> before calling your system's
|
|
C<strftime()> function, except that the C<isdst> value is not affected.
|
|
|
|
The string for Tuesday, December 12, 1995.
|
|
|
|
$str = POSIX::strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 );
|
|
print "$str\n";
|
|
|
|
=item strlen
|
|
|
|
strlen() is C-specific, use C<length()> instead, see L<perlfunc/length>.
|
|
|
|
=item strncat
|
|
|
|
strncat() is C-specific, use C<.=> instead, see L<perlop>.
|
|
|
|
=item strncmp
|
|
|
|
strncmp() is C-specific, use C<eq> instead, see L<perlop>.
|
|
|
|
=item strncpy
|
|
|
|
strncpy() is C-specific, use C<=> instead, see L<perlop>.
|
|
|
|
=item strpbrk
|
|
|
|
strpbrk() is C-specific, use regular expressions instead,
|
|
see L<perlre>.
|
|
|
|
=item strrchr
|
|
|
|
strrchr() is C-specific, see L<perlfunc/rindex> instead.
|
|
|
|
=item strspn
|
|
|
|
strspn() is C-specific, use regular expressions instead,
|
|
see L<perlre>.
|
|
|
|
=item strstr
|
|
|
|
This is identical to Perl's builtin C<index()> function,
|
|
see L<perlfunc/index>.
|
|
|
|
=item strtod
|
|
|
|
String to double translation. Returns the parsed number and the number
|
|
of characters in the unparsed portion of the string. Truly
|
|
POSIX-compliant systems set $! ($ERRNO) to indicate a translation
|
|
error, so clear $! before calling strtod. However, non-POSIX systems
|
|
may not check for overflow, and therefore will never set $!.
|
|
|
|
strtod should respect any POSIX I<setlocale()> settings.
|
|
|
|
To parse a string $str as a floating point number use
|
|
|
|
$! = 0;
|
|
($num, $n_unparsed) = POSIX::strtod($str);
|
|
|
|
The second returned item and $! can be used to check for valid input:
|
|
|
|
if (($str eq '') || ($n_unparsed != 0) || !$!) {
|
|
die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
|
|
}
|
|
|
|
When called in a scalar context strtod returns the parsed number.
|
|
|
|
=item strtok
|
|
|
|
strtok() is C-specific, use regular expressions instead, see
|
|
L<perlre>, or L<perlfunc/split>.
|
|
|
|
=item strtol
|
|
|
|
String to (long) integer translation. Returns the parsed number and
|
|
the number of characters in the unparsed portion of the string. Truly
|
|
POSIX-compliant systems set $! ($ERRNO) to indicate a translation
|
|
error, so clear $! before calling strtol. However, non-POSIX systems
|
|
may not check for overflow, and therefore will never set $!.
|
|
|
|
strtol should respect any POSIX I<setlocale()> settings.
|
|
|
|
To parse a string $str as a number in some base $base use
|
|
|
|
$! = 0;
|
|
($num, $n_unparsed) = POSIX::strtol($str, $base);
|
|
|
|
The base should be zero or between 2 and 36, inclusive. When the base
|
|
is zero or omitted strtol will use the string itself to determine the
|
|
base: a leading "0x" or "0X" means hexadecimal; a leading "0" means
|
|
octal; any other leading characters mean decimal. Thus, "1234" is
|
|
parsed as a decimal number, "01234" as an octal number, and "0x1234"
|
|
as a hexadecimal number.
|
|
|
|
The second returned item and $! can be used to check for valid input:
|
|
|
|
if (($str eq '') || ($n_unparsed != 0) || !$!) {
|
|
die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
|
|
}
|
|
|
|
When called in a scalar context strtol returns the parsed number.
|
|
|
|
=item strtoul
|
|
|
|
String to unsigned (long) integer translation. strtoul() is identical
|
|
to strtol() except that strtoul() only parses unsigned integers. See
|
|
L</strtol> for details.
|
|
|
|
Note: Some vendors supply strtod() and strtol() but not strtoul().
|
|
Other vendors that do supply strtoul() parse "-1" as a valid value.
|
|
|
|
=item strxfrm
|
|
|
|
String transformation. Returns the transformed string.
|
|
|
|
$dst = POSIX::strxfrm( $src );
|
|
|
|
Used in conjunction with the C<strcoll()> function, see L</strcoll>.
|
|
|
|
Not really needed since Perl can do this transparently, see
|
|
L<perllocale>.
|
|
|
|
=item sysconf
|
|
|
|
Retrieves values of system configurable variables.
|
|
|
|
The following will get the machine's clock speed.
|
|
|
|
$clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item system
|
|
|
|
This is identical to Perl's builtin C<system()> function, see
|
|
L<perlfunc/system>.
|
|
|
|
=item tan
|
|
|
|
This is identical to the C function C<tan()>, returning the
|
|
tangent of the numerical argument. See also L<Math::Trig>.
|
|
|
|
=item tanh
|
|
|
|
This is identical to the C function C<tanh()>, returning the
|
|
hyperbolic tangent of the numerical argument. See also L<Math::Trig>.
|
|
|
|
=item tcdrain
|
|
|
|
This is similar to the C function C<tcdrain()> for draining
|
|
the output queue of its argument stream.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item tcflow
|
|
|
|
This is similar to the C function C<tcflow()> for controlling
|
|
the flow of its argument stream.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item tcflush
|
|
|
|
This is similar to the C function C<tcflush()> for flushing
|
|
the I/O buffers of its argumeny stream.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item tcgetpgrp
|
|
|
|
This is identical to the C function C<tcgetpgrp()> for returning the
|
|
process group identifier of the foreground process group of the controlling
|
|
terminal.
|
|
|
|
=item tcsendbreak
|
|
|
|
This is similar to the C function C<tcsendbreak()> for sending
|
|
a break on its argument stream.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item tcsetpgrp
|
|
|
|
This is similar to the C function C<tcsetpgrp()> for setting the
|
|
process group identifier of the foreground process group of the controlling
|
|
terminal.
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item time
|
|
|
|
This is identical to Perl's builtin C<time()> function
|
|
for returning the number of seconds since the epoch
|
|
(whatever it is for the system), see L<perlfunc/time>.
|
|
|
|
=item times
|
|
|
|
The times() function returns elapsed realtime since some point in the past
|
|
(such as system startup), user and system times for this process, and user
|
|
and system times used by child processes. All times are returned in clock
|
|
ticks.
|
|
|
|
($realtime, $user, $system, $cuser, $csystem) = POSIX::times();
|
|
|
|
Note: Perl's builtin C<times()> function returns four values, measured in
|
|
seconds.
|
|
|
|
=item tmpfile
|
|
|
|
Use method C<IO::File::new_tmpfile()> instead, or see L<File::Temp>.
|
|
|
|
=item tmpnam
|
|
|
|
Returns a name for a temporary file.
|
|
|
|
$tmpfile = POSIX::tmpnam();
|
|
|
|
For security reasons, which are probably detailed in your system's
|
|
documentation for the C library tmpnam() function, this interface
|
|
should not be used; instead see L<File::Temp>.
|
|
|
|
=item tolower
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using the C<lc()> function,
|
|
see L<perlfunc/lc>, or the equivalent C<\L> operator inside doublequotish
|
|
strings.
|
|
|
|
=item toupper
|
|
|
|
This is identical to the C function, except that it can apply to a single
|
|
character or to a whole string. Consider using the C<uc()> function,
|
|
see L<perlfunc/uc>, or the equivalent C<\U> operator inside doublequotish
|
|
strings.
|
|
|
|
=item ttyname
|
|
|
|
This is identical to the C function C<ttyname()> for returning the
|
|
name of the current terminal.
|
|
|
|
=item tzname
|
|
|
|
Retrieves the time conversion information from the C<tzname> variable.
|
|
|
|
POSIX::tzset();
|
|
($std, $dst) = POSIX::tzname();
|
|
|
|
=item tzset
|
|
|
|
This is identical to the C function C<tzset()> for setting
|
|
the current timezone based on the environment variable C<TZ>,
|
|
to be used by C<ctime()>, C<localtime()>, C<mktime()>, and C<strftime()>
|
|
functions.
|
|
|
|
=item umask
|
|
|
|
This is identical to Perl's builtin C<umask()> function
|
|
for setting (and querying) the file creation permission mask,
|
|
see L<perlfunc/umask>.
|
|
|
|
=item uname
|
|
|
|
Get name of current operating system.
|
|
|
|
($sysname, $nodename, $release, $version, $machine) = POSIX::uname();
|
|
|
|
Note that the actual meanings of the various fields are not
|
|
that well standardized, do not expect any great portability.
|
|
The C<$sysname> might be the name of the operating system,
|
|
the C<$nodename> might be the name of the host, the C<$release>
|
|
might be the (major) release number of the operating system,
|
|
the C<$version> might be the (minor) release number of the
|
|
operating system, and the C<$machine> might be a hardware identifier.
|
|
Maybe.
|
|
|
|
=item ungetc
|
|
|
|
Use method C<IO::Handle::ungetc()> instead.
|
|
|
|
=item unlink
|
|
|
|
This is identical to Perl's builtin C<unlink()> function
|
|
for removing files, see L<perlfunc/unlink>.
|
|
|
|
=item utime
|
|
|
|
This is identical to Perl's builtin C<utime()> function
|
|
for changing the time stamps of files and directories,
|
|
see L<perlfunc/utime>.
|
|
|
|
=item vfprintf
|
|
|
|
vfprintf() is C-specific, see L<perlfunc/printf> instead.
|
|
|
|
=item vprintf
|
|
|
|
vprintf() is C-specific, see L<perlfunc/printf> instead.
|
|
|
|
=item vsprintf
|
|
|
|
vsprintf() is C-specific, see L<perlfunc/sprintf> instead.
|
|
|
|
=item wait
|
|
|
|
This is identical to Perl's builtin C<wait()> function,
|
|
see L<perlfunc/wait>.
|
|
|
|
=item waitpid
|
|
|
|
Wait for a child process to change state. This is identical to Perl's
|
|
builtin C<waitpid()> function, see L<perlfunc/waitpid>.
|
|
|
|
$pid = POSIX::waitpid( -1, &POSIX::WNOHANG );
|
|
print "status = ", ($? / 256), "\n";
|
|
|
|
=item wcstombs
|
|
|
|
This is identical to the C function C<wcstombs()>.
|
|
Perl does not have any support for the wide and multibyte
|
|
characters of the C standards, so this might be a rather
|
|
useless function.
|
|
|
|
=item wctomb
|
|
|
|
This is identical to the C function C<wctomb()>.
|
|
Perl does not have any support for the wide and multibyte
|
|
characters of the C standards, so this might be a rather
|
|
useless function.
|
|
|
|
=item write
|
|
|
|
Write to a file. This uses file descriptors such as those obtained by
|
|
calling C<POSIX::open>.
|
|
|
|
$fd = POSIX::open( "foo", &POSIX::O_WRONLY );
|
|
$buf = "hello";
|
|
$bytes = POSIX::write( $b, $buf, 5 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
See also L<perlfunc/syswrite>.
|
|
|
|
=back
|
|
|
|
=head1 CLASSES
|
|
|
|
=head2 POSIX::SigAction
|
|
|
|
=over 8
|
|
|
|
=item new
|
|
|
|
Creates a new C<POSIX::SigAction> object which corresponds to the C
|
|
C<struct sigaction>. This object will be destroyed automatically when it is
|
|
no longer needed. The first parameter is the fully-qualified name of a sub
|
|
which is a signal-handler. The second parameter is a C<POSIX::SigSet>
|
|
object, it defaults to the empty set. The third parameter contains the
|
|
C<sa_flags>, it defaults to 0.
|
|
|
|
$sigset = POSIX::SigSet->new(SIGINT, SIGQUIT);
|
|
$sigaction = POSIX::SigAction->new( 'main::handler', $sigset, &POSIX::SA_NOCLDSTOP );
|
|
|
|
This C<POSIX::SigAction> object should be used with the C<POSIX::sigaction()>
|
|
function.
|
|
|
|
=back
|
|
|
|
=head2 POSIX::SigSet
|
|
|
|
=over 8
|
|
|
|
=item new
|
|
|
|
Create a new SigSet object. This object will be destroyed automatically
|
|
when it is no longer needed. Arguments may be supplied to initialize the
|
|
set.
|
|
|
|
Create an empty set.
|
|
|
|
$sigset = POSIX::SigSet->new;
|
|
|
|
Create a set with SIGUSR1.
|
|
|
|
$sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 );
|
|
|
|
=item addset
|
|
|
|
Add a signal to a SigSet object.
|
|
|
|
$sigset->addset( &POSIX::SIGUSR2 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item delset
|
|
|
|
Remove a signal from the SigSet object.
|
|
|
|
$sigset->delset( &POSIX::SIGUSR2 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item emptyset
|
|
|
|
Initialize the SigSet object to be empty.
|
|
|
|
$sigset->emptyset();
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item fillset
|
|
|
|
Initialize the SigSet object to include all signals.
|
|
|
|
$sigset->fillset();
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item ismember
|
|
|
|
Tests the SigSet object to see if it contains a specific signal.
|
|
|
|
if( $sigset->ismember( &POSIX::SIGUSR1 ) ){
|
|
print "contains SIGUSR1\n";
|
|
}
|
|
|
|
=back
|
|
|
|
=head2 POSIX::Termios
|
|
|
|
=over 8
|
|
|
|
=item new
|
|
|
|
Create a new Termios object. This object will be destroyed automatically
|
|
when it is no longer needed. A Termios object corresponds to the termios
|
|
C struct. new() mallocs a new one, getattr() fills it from a file descriptor,
|
|
and setattr() sets a file descriptor's parameters to match Termios' contents.
|
|
|
|
$termios = POSIX::Termios->new;
|
|
|
|
=item getattr
|
|
|
|
Get terminal control attributes.
|
|
|
|
Obtain the attributes for stdin.
|
|
|
|
$termios->getattr()
|
|
|
|
Obtain the attributes for stdout.
|
|
|
|
$termios->getattr( 1 )
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item getcc
|
|
|
|
Retrieve a value from the c_cc field of a termios object. The c_cc field is
|
|
an array so an index must be specified.
|
|
|
|
$c_cc[1] = $termios->getcc(1);
|
|
|
|
=item getcflag
|
|
|
|
Retrieve the c_cflag field of a termios object.
|
|
|
|
$c_cflag = $termios->getcflag;
|
|
|
|
=item getiflag
|
|
|
|
Retrieve the c_iflag field of a termios object.
|
|
|
|
$c_iflag = $termios->getiflag;
|
|
|
|
=item getispeed
|
|
|
|
Retrieve the input baud rate.
|
|
|
|
$ispeed = $termios->getispeed;
|
|
|
|
=item getlflag
|
|
|
|
Retrieve the c_lflag field of a termios object.
|
|
|
|
$c_lflag = $termios->getlflag;
|
|
|
|
=item getoflag
|
|
|
|
Retrieve the c_oflag field of a termios object.
|
|
|
|
$c_oflag = $termios->getoflag;
|
|
|
|
=item getospeed
|
|
|
|
Retrieve the output baud rate.
|
|
|
|
$ospeed = $termios->getospeed;
|
|
|
|
=item setattr
|
|
|
|
Set terminal control attributes.
|
|
|
|
Set attributes immediately for stdout.
|
|
|
|
$termios->setattr( 1, &POSIX::TCSANOW );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item setcc
|
|
|
|
Set a value in the c_cc field of a termios object. The c_cc field is an
|
|
array so an index must be specified.
|
|
|
|
$termios->setcc( &POSIX::VEOF, 1 );
|
|
|
|
=item setcflag
|
|
|
|
Set the c_cflag field of a termios object.
|
|
|
|
$termios->setcflag( $c_cflag | &POSIX::CLOCAL );
|
|
|
|
=item setiflag
|
|
|
|
Set the c_iflag field of a termios object.
|
|
|
|
$termios->setiflag( $c_iflag | &POSIX::BRKINT );
|
|
|
|
=item setispeed
|
|
|
|
Set the input baud rate.
|
|
|
|
$termios->setispeed( &POSIX::B9600 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item setlflag
|
|
|
|
Set the c_lflag field of a termios object.
|
|
|
|
$termios->setlflag( $c_lflag | &POSIX::ECHO );
|
|
|
|
=item setoflag
|
|
|
|
Set the c_oflag field of a termios object.
|
|
|
|
$termios->setoflag( $c_oflag | &POSIX::OPOST );
|
|
|
|
=item setospeed
|
|
|
|
Set the output baud rate.
|
|
|
|
$termios->setospeed( &POSIX::B9600 );
|
|
|
|
Returns C<undef> on failure.
|
|
|
|
=item Baud rate values
|
|
|
|
B38400 B75 B200 B134 B300 B1800 B150 B0 B19200 B1200 B9600 B600 B4800 B50 B2400 B110
|
|
|
|
=item Terminal interface values
|
|
|
|
TCSADRAIN TCSANOW TCOON TCIOFLUSH TCOFLUSH TCION TCIFLUSH TCSAFLUSH TCIOFF TCOOFF
|
|
|
|
=item c_cc field values
|
|
|
|
VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS
|
|
|
|
=item c_cflag field values
|
|
|
|
CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD
|
|
|
|
=item c_iflag field values
|
|
|
|
BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK
|
|
|
|
=item c_lflag field values
|
|
|
|
ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP
|
|
|
|
=item c_oflag field values
|
|
|
|
OPOST
|
|
|
|
=back
|
|
|
|
=head1 PATHNAME CONSTANTS
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
_PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX _PC_PIPE_BUF _PC_VDISABLE
|
|
|
|
=back
|
|
|
|
=head1 POSIX CONSTANTS
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
_POSIX_ARG_MAX _POSIX_CHILD_MAX _POSIX_CHOWN_RESTRICTED _POSIX_JOB_CONTROL _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_NO_TRUNC _POSIX_OPEN_MAX _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SAVED_IDS _POSIX_SSIZE_MAX _POSIX_STREAM_MAX _POSIX_TZNAME_MAX _POSIX_VDISABLE _POSIX_VERSION
|
|
|
|
=back
|
|
|
|
=head1 SYSTEM CONFIGURATION
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
_SC_ARG_MAX _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_SAVED_IDS _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION
|
|
|
|
=back
|
|
|
|
=head1 ERRNO
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY EBADF
|
|
EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ
|
|
EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS EINTR
|
|
EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK EMSGSIZE ENAMETOOLONG
|
|
ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS ENODEV ENOENT ENOEXEC
|
|
ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR
|
|
ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM EPFNOSUPPORT EPIPE
|
|
EPROCLIM EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART EROFS
|
|
ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS
|
|
ETXTBSY EUSERS EWOULDBLOCK EXDEV
|
|
|
|
=back
|
|
|
|
=head1 FCNTL
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_OK F_RDLCK F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK O_RDONLY O_RDWR O_TRUNC O_WRONLY
|
|
|
|
=back
|
|
|
|
=head1 FLOAT
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
DBL_DIG DBL_EPSILON DBL_MANT_DIG DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP FLT_DIG FLT_EPSILON FLT_MANT_DIG FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP FLT_RADIX FLT_ROUNDS LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP
|
|
|
|
=back
|
|
|
|
=head1 LIMITS
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX
|
|
|
|
=back
|
|
|
|
=head1 LOCALE
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME
|
|
|
|
=back
|
|
|
|
=head1 MATH
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
HUGE_VAL
|
|
|
|
=back
|
|
|
|
=head1 SIGNAL
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK SA_RESETHAND SA_RESTART
|
|
SA_SIGINFO SIGABRT SIGALRM SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT
|
|
SIGKILL SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN SIGTTOU
|
|
SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK
|
|
SIG_UNBLOCK
|
|
|
|
=back
|
|
|
|
=head1 STAT
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR
|
|
|
|
=item Macros
|
|
|
|
S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG
|
|
|
|
=back
|
|
|
|
=head1 STDLIB
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX RAND_MAX
|
|
|
|
=back
|
|
|
|
=head1 STDIO
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid L_tmpname TMP_MAX
|
|
|
|
=back
|
|
|
|
=head1 TIME
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
CLK_TCK CLOCKS_PER_SEC
|
|
|
|
=back
|
|
|
|
=head1 UNISTD
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
R_OK SEEK_CUR SEEK_END SEEK_SET STDIN_FILENO STDOUT_FILENO STDERR_FILENO W_OK X_OK
|
|
|
|
=back
|
|
|
|
=head1 WAIT
|
|
|
|
=over 8
|
|
|
|
=item Constants
|
|
|
|
WNOHANG WUNTRACED
|
|
|
|
=item Macros
|
|
|
|
WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG
|
|
|
|
=back
|
|
|