POSIX - Perl interface to IEEE Std 1003.1
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
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.
Everything is exported by default with the exception of any POSIX functions with the same name as a built-in Perl function, such as
abs, alarm, rmdir, write, etc.., which will be exported
only if you ask for them explicitly. This is an unfortunate backwards
compatibility feature. You can stop the exporting by saying use POSIX () and then use the fully qualified names (ie. POSIX::SEEK_END).
perldoc2tree.cgi: /usr/lib/perl5/5.8.5/i386-linux-thread-multi/POSIX.pod: cannot resolve L
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 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.
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.
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.
_exit(). It exits the program
immediately which means among other things buffered I/O is not flushed.
Note that when using threads and in Linux this is not a good way to exit a thread because in Linux processes and threads are kind of the same thing (Note: while this is the situation in early 2003 there are projects under way to have threads with more POSIXly semantics in Linux). If you want not to return from a thread, detach the thread.
abort(). It terminates the
process with a SIGABRT signal unless caught by a signal handler or if the handler does not return normally (it e.g. does a longjmp).
abs() function, returning
the absolute value of its numerical argument.
if( POSIX::access( "/", &POSIX::R_OK ) ){
print "have read permission\n";
}
Returns undef on failure. Note: do not use access() for
security purposes. Between the access() call and the operation
you are preparing for the permissions might change: a classic
race condition.
acos(), returning
the arcus cosine of its numerical argument. See also the Math::Trig manpage.
alarm() function,
either for arming or disarming the SIGARLM timer.
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 $mon is zero-based: January equals 0. The $year is
1900-based: 2001 equals 101. The $wday, $yday, and $isdst
default to zero (and the first two are usually ignored anyway).
asin(), returning
the arcus sine of its numerical argument. See also the Math::Trig manpage.
atan(), returning the
arcus tangent of its numerical argument. See also the Math::Trig manpage.
atan2() function, returning
the arcus tangent defined by its two numerical arguments, the y
coordinate and the x coordinate. See also the Math::Trig manpage.
atexit() is C-specific: use END {} instead, see perlsub.
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.
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 perlfunc/int.
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 perlfunc/int.
bsearch() not supplied. For doing binary search on wordlists,
see the Search::Dict manpage.
calloc() is C-specific. Perl does memory management transparently.
ceil(), returning the smallest integer value greater than or equal to the given numerical argument.
chdir() function, allowing
one to change the working (default) directory, see perlfunc/chdir.
chmod() function, allowing
one to change file and directory permissions, see perlfunc/chmod.
chown() function, allowing one
to change file and directory owners and groups, see perlfunc/chown.
IO::Handle::clearerr() instead, to reset the error
state (if any) and EOF state (if any) of the given stream.
clock(), returning the
amount of spent processor time in microseconds.
POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
POSIX::close( $fd );
Returns undef on failure.
See also perlfunc/close.
closedir() function for closing
a directory handle, see perlfunc/closedir.
cos() function, for returning
the cosine of its numerical argument, see perlfunc/cos.
See also the Math::Trig manpage.
cosh(), for returning
the hyperbolic cosine of its numeric argument. See also the Math::Trig manpage.
POSIX::open. Use POSIX::close to close the file.
$fd = POSIX::creat( "foo", 0611 );
POSIX::close( $fd );
See also perlfunc/sysopen and its O_CREAT flag.
$path = POSIX::ctermid();
ctime() and equivalent
to asctime(localtime(...)), see asctime and localtime.
$name = POSIX::cuserid();
difftime(), for returning
the time difference (in seconds) between two times (as returned
by time()), see time.
div() is C-specific, use perlfunc/int on the usual / division and
the modulus %.
dup(), for duplicating a file
descriptor.
This uses file descriptors such as those obtained by calling
POSIX::open.
Returns undef on failure.
dup2(), for duplicating a file
descriptor to an another known file descriptor.
This uses file descriptors such as those obtained by calling
POSIX::open.
Returns undef on failure.
$errno = POSIX::errno();
This identical to the numerical values of the $!, see perlvar/$ERRNO.
execl() is C-specific, see perlfunc/exec.
execle() is C-specific, see perlfunc/exec.
execlp() is C-specific, see perlfunc/exec.
execv() is C-specific, see perlfunc/exec.
execve() is C-specific, see perlfunc/exec.
execvp() is C-specific, see perlfunc/exec.
exit() function for exiting the
program, see perlfunc/exit.
exp() function for
returning the exponent (e-based) of the numerical argument,
see perlfunc/exp.
abs() function for returning
the absolute value of the numerical argument, see perlfunc/abs.
IO::Handle::close() instead, or see perlfunc/close.
fcntl() function,
see perlfunc/fcntl.
IO::Handle::new_from_fd() instead, or see perlfunc/open.
IO::Handle::eof() instead, or see perlfunc/eof.
IO::Handle::error() instead.
IO::Handle::flush() instead.
See also perlvar/$OUTPUT_AUTOFLUSH.
IO::Handle::getc() instead, or see perlfunc/read.
IO::Seekable::getpos() instead, or see L/seek.
IO::Handle::gets() instead. Similar to <>, also known
as perlfunc/readline.
IO::Handle::fileno() instead, or see perlfunc/fileno.
floor(), returning the largest integer value less than or equal to the numerical argument.
fmod().
$r = fmod($x, $y);
It returns the remainder $r = $x - $n*$y, where $n = trunc($x/$y).
The $r has the same sign as $x and magnitude (absolute value) less than the magnitude of $y.
IO::File::open() instead, or see perlfunc/open.
fork() function
for duplicating the current process, see perlfunc/fork
and perlfork if you are in Windows.
POSIX::open.
The following will determine the maximum length of the longest allowable
pathname on the filesystem which holds /var/foo.
$fd = POSIX::open( "/var/foo", &POSIX::O_RDONLY );
$path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX );
Returns undef on failure.
fprintf() is C-specific, see perlfunc/printf instead.
fputc() is C-specific, see perlfunc/print instead.
fputs() is C-specific, see perlfunc/print instead.
fread() is C-specific, see perlfunc/read instead.
free() is C-specific. Perl does memory management transparently.
freopen() is C-specific, see perlfunc/open instead.
($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
fscanf() is C-specific, use <> and regular expressions instead.
IO::Seekable::seek() instead, or see perlfunc/seek.
IO::Seekable::setpos() instead, or seek perlfunc/seek.
POSIX::open. The data returned is identical to the data from
Perl's builtin stat function.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
@stats = POSIX::fstat( $fd );
IO::Handle::sync() instead.
IO::Seekable::tell() instead, or see perlfunc/tell.
fwrite() is C-specific, see perlfunc/print instead.
getc() function,
see perlfunc/getc.
getc(),
see perlfunc/getc.
$(, see perlvar/$EGID.
%ENV array.
$>
variable, see perlvar/$EUID.
$), see perlvar/$GID.
getgrgid() function for
returning group entries by group identifiers, see
perlfunc/getgrgid.
getgrnam() function for
returning group entries by group names, see perlfunc/getgrnam.
$), see perlvar/$GID.
getlogin() function for
returning the user name associated with the current session, see
perlfunc/getlogin.
getpgrp() function for
returning the prcess group identifier of the current process, see
perlfunc/getpgrp.
$$, see perlvar/$PID.
getppid() function for
returning the process identifier of the parent process of the current
process , see perlfunc/getppid.
getpwnam() function for
returning user entries by user names, see perlfunc/getpwnam.
getpwuid() function for
returning user entries by user identifiers, see perlfunc/getpwuid.
STDIN, similar to <>, also known
as the readline() function, see perlfunc/readline.
NOTE: if you have C programs that still use gets(), be very
afraid. The gets() function is a source of endless grief because
it has no buffer overrun checks. It should never be used. The
fgets() function should be preferred instead.
$< variable,
see perlvar/$UID.
gmtime() function for
converting seconds since the epoch to a date in Greenwich Mean Time,
see perlfunc/gmtime.
isalnum. Does not work on
Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:alnum:]]/ construct instead, or possibly
the /\w/ construct.
isalpha. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:alpha:]]/ construct instead.
-t operator, see perlfunc/-X.
iscntrl. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:cntrl:]]/ construct instead.
isdigit (unlikely, but
still possible). Does not work on Unicode characters code point 256
or higher. Consider using regular expressions and the /[[:digit:]]/
construct instead, or the /\d/ construct.
isgraph. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:graph:]]/ construct instead.
islower. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:lower:]]/ construct instead. Do not use
/[a-z]/.
isprint. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:print:]]/ construct instead.
ispunct. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:punct:]]/ construct instead.
isspace. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:space:]]/ construct instead, or the /\s/
construct. (Note that /\s/ and /[[:space:]]/ are slightly
different in that /[[:space:]]/ can normally match a vertical tab,
while /\s/ does not.)
isupper. Does not work
on Unicode characters code point 256 or higher. Consider using regular
expressions and the /[[:upper:]]/ construct instead. Do not use
/[A-Z]/.
isxdigit (unlikely, but still possible).
Does not work on Unicode characters code point 256 or higher.
Consider using regular expressions and the /[[:xdigit:]]/
construct instead, or simply /[0-9a-f]/i.
kill() function for sending
signals to processes (often to terminate them), see perlfunc/kill.
labs() is C-specific, see perlfunc/abs instead.
ldexp()
for multiplying floating point numbers with powers of two.
$x_quadrupled = POSIX::ldexp($x, 2);
ldiv() is C-specific, use / and int() instead.
link() function
for creating hard links into files, see perlfunc/link.
Here is how to query the database for the 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";
localtime() function for
converting seconds since the epoch to a date see perlfunc/localtime.
log() function,
returning the natural (e-based) logarithm of the numerical argument,
see perlfunc/log.
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 }
longjmp() is C-specific: use perlfunc/die instead.
POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY );
$off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
Returns undef on failure.
malloc() is C-specific. Perl does memory management transparently.
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.
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.
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.
memchr() is C-specific, see perlfunc/index instead.
memcmp() is C-specific, use eq instead, see perlop.
memcpy() is C-specific, use =, see perlop, or see perlfunc/substr.
memmove() is C-specific, use =, see perlop, or see perlfunc/substr.
memset() is C-specific, use x instead, see perlop.
mkdir() function
for creating directories, see perlfunc/mkdir.
mkfifo() for creating
FIFO special files.
if (mkfifo($path, $mode)) { ....
Returns undef on failure. The $mode is similar to the
mode of mkdir(), see perlfunc/mkdir.
Synopsis:
mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
The month (mon), weekday (wday), and yearday (yday) begin at zero.
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
year (year) is given in years since 1900. I.e. The year 1995 is 95; the
year 2001 is 101. Consult your system's 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 undef on failure.
($fractional, $integral) = POSIX::modf( 3.14 );
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 undef on failure.
offsetof() is C-specific, you probably want to see perlfunc/pack instead.
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 undef on failure.
See also perlfunc/sysopen.
$dir = POSIX::opendir( "/var" );
@files = POSIX::readdir( $dir );
POSIX::closedir( $dir );
Returns undef on failure.
The following will determine the maximum length of the longest allowable
pathname on the filesystem which holds /var.
$path_max = POSIX::pathconf( "/var", &POSIX::_PC_PATH_MAX );
Returns undef on failure.
pause(), which suspends
the execution of the current process until a signal is received.
Returns undef on failure.
perror(), which outputs to the
standard error stream the specified message followed by ``: '' and the
current error string. Use the warn() function and the $!
variable instead, see perlfunc/warn and perlvar/$ERRNO.
POSIX::open.
($fd0, $fd1) = POSIX::pipe();
POSIX::write( $fd0, "hello", 5 );
POSIX::read( $fd1, $buf, 5 );
See also perlfunc/pipe.
$x raised to the power $exponent.
$ret = POSIX::pow( $x, $exponent );
You can also use the ** operator, see perlop.
putc() is C-specific, see perlfunc/print instead.
putchar() is C-specific, see perlfunc/print instead.
puts() is C-specific, see perlfunc/print instead.
qsort() is C-specific, see perlfunc/sort instead.
$$ in perlvar/$PID.
rand() is non-portable, see perlfunc/rand instead.
POSIX::open. If the buffer $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 undef on failure.
See also perlfunc/sysread.
readdir() function
for reading directory entries, see perlfunc/readdir.
realloc() is C-specific. Perl does memory management transparently.
unlink() function
for removing files, see perlfunc/unlink.
rename() function
for renaming files, see perlfunc/rename.
rewinddir() function for
rewinding directory entry streams, see perlfunc/rewinddir.
rmdir() function
for removing (empty) directories, see perlfunc/rmdir.
scanf() is C-specific, use <> and regular expressions instead,
see perlre.
$) variable, see perlvar/$GID, except that the latter
will change only the real user identifier, and that the setgid()
uses only a single numeric argument, as opposed to a space-separated
list of numbers.
setjmp() is C-specific: use eval {} instead,
see perlfunc/eval.
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").
$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 "").
Please see your systems setlocale(3) documentation for the locale environment variables' meaning or consult perllocale.
$loc = setlocale( LC_CTYPE, "" );
The following will set the LC_COLLATE behaviour to Argentinian Spanish. NOTE: The naming and availability of locales depends on your operating system. Please consult perllocale for how to find out which locales are available in your system.
$loc = setlocale( LC_ALL, "es_AR.ISO8859-1" );
setpgid() for
setting the process group identifier of the current process.
Returns undef on failure.
setsid() for
setting the session identifier of the current process.
$< variable, see perlvar/$UID, except that the latter
will change only the real user identifier.
POSIX::SigAction objects for the
action and oldaction arguments. Consult your system's sigaction
manpage for details.
Synopsis:
sigaction(signal, action, oldaction = 0)
Returns undef on failure. The signal must be a number (like
SIGHUP), not a string (like ``SIGHUP''), though Perl does try hard
to understand you.
siglongjmp() is C-specific: use perlfunc/die instead.
POSIX::SigSet
objects for the sigset argument. Consult your system's sigpending
manpage for details.
Synopsis:
sigpending(sigset)
Returns undef on failure.
POSIX::SigSet objects for the sigset and oldsigset arguments.
Consult your system's sigprocmask manpage for details.
Synopsis:
sigprocmask(how, sigset, oldsigset = 0)
Returns undef on failure.
sigsetjmp() is C-specific: use eval {} instead,
see perlfunc/eval.
POSIX::SigSet objects for the signal_mask argument. Consult your
system's sigsuspend manpage for details.
Synopsis:
sigsuspend(signal_mask)
Returns undef on failure.
sin() function
for returning the sine of the numerical argument,
see perlfunc/sin. See also the Math::Trig manpage.
sinh()
for returning the hyperbolic sine of the numerical argument.
See also the Math::Trig manpage.
sleep() function
for suspending the execution of the current for process for certain
number of seconds, see perlfunc/sleep. There is one significant
difference, however: POSIX::sleep() returns the number of
unslept seconds, while the CORE::sleep() returns the
number of slept seconds.
sprintf() function
for returning a string that has the arguments formatted as requested,
see perlfunc/sprintf.
sqrt() function.
for returning the square root of the numerical argument,
see perlfunc/sqrt.
sscanf() is C-specific, use regular expressions instead,
see perlre.
stat() function
for retutning information about files and directories.
strcat() is C-specific, use .= instead, see perlop.
strchr() is C-specific, see perlfunc/index instead.
strcmp() is C-specific, use eq or cmp instead, see perlop.
strcoll()
for collating (comparing) strings transformed using
the strxfrm() function. Not really needed since
Perl can do this transparently, see perllocale.
strcpy() is C-specific, use = instead, see perlop.
strcspn() is C-specific, use regular expressions instead,
see perlre.
$!, see perlvar/$ERRNO.
Synopsis:
strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
The month (mon), weekday (wday), and yearday (yday) begin at zero.
I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The
year (year) is given in years since 1900. I.e., the year 1995 is 95; the
year 2001 is 101. Consult your system's strftime() manpage for details
about these and the other arguments.
If you want your code to be portable, your format (fmt) argument
should use only the conversion specifiers defined by the ANSI C
standard (C89, to play safe). These are aAbBcdHIjmMpSUwWxXyYZ%.
But even then, the results of some of the conversion specifiers are
non-portable. For example, the specifiers aAbBcpZ change according
to the locale settings of the user, and both how to set locales (the locale names) and what output to expect are non-standard.
The specifier c changes according to the timezone settings of the
user and the timezone computation rules of the operating system.
The Z specifier is notoriously unportable since the names of
timezones are non-standard. Sticking to the numeric specifiers is the
safest route.
The given arguments are made consistent as though by calling
mktime() before calling your system's strftime() function,
except that the 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";
strlen() is C-specific, use length() instead, see perlfunc/length.
strncat() is C-specific, use .= instead, see perlop.
strncmp() is C-specific, use eq instead, see perlop.
strncpy() is C-specific, use = instead, see perlop.
strpbrk() is C-specific, use regular expressions instead,
see perlre.
strrchr() is C-specific, see perlfunc/rindex instead.
strspn() is C-specific, use regular expressions instead,
see perlre.
index() function,
see perlfunc/index.
strtod should respect any POSIX 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.
strtok() is C-specific, use regular expressions instead, see
perlre, or perlfunc/split.
strtol should respect any POSIX 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.
strtoul() is identical
to strtol() except that strtoul() only parses unsigned integers. See
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.
$dst = POSIX::strxfrm( $src );
Used in conjunction with the strcoll() function, see strcoll.
Not really needed since Perl can do this transparently, see perllocale.
The following will get the machine's clock speed.
$clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
Returns undef on failure.
system() function, see
perlfunc/system.
tan(), returning the
tangent of the numerical argument. See also the Math::Trig manpage.
tanh(), returning the
hyperbolic tangent of the numerical argument. See also the Math::Trig manpage.
tcdrain() for draining
the output queue of its argument stream.
Returns undef on failure.
tcflow() for controlling
the flow of its argument stream.
Returns undef on failure.
tcflush() for flushing
the I/O buffers of its argument stream.
Returns undef on failure.
tcgetpgrp() for returning the
process group identifier of the foreground process group of the controlling
terminal.
tcsendbreak() for sending
a break on its argument stream.
Returns undef on failure.
tcsetpgrp() for setting the
process group identifier of the foreground process group of the controlling
terminal.
Returns undef on failure.
time() function
for returning the number of seconds since the epoch
(whatever it is for the system), see perlfunc/time.
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 times() function returns four values, measured in
seconds.
IO::File::new_tmpfile() instead, or see the File::Temp manpage.
$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 the File::Temp manpage.
lc() function,
see perlfunc/lc, or the equivalent \L operator inside doublequotish
strings.
uc() function,
see perlfunc/uc, or the equivalent \U operator inside doublequotish
strings.
ttyname() for returning the
name of the current terminal.
tzname variable.
POSIX::tzset();
($std, $dst) = POSIX::tzname();
tzset() for setting
the current timezone based on the environment variable TZ,
to be used by ctime(), localtime(), mktime(), and strftime()
functions.
umask() function
for setting (and querying) the file creation permission mask,
see perlfunc/umask.
($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 $sysname might be the name of the operating system,
the $nodename might be the name of the host, the $release
might be the (major) release number of the operating system,
the $version might be the (minor) release number of the
operating system, and the $machine might be a hardware identifier.
Maybe.
IO::Handle::ungetc() instead.
unlink() function
for removing files, see perlfunc/unlink.
utime() function
for changing the time stamps of files and directories,
see perlfunc/utime.
vfprintf() is C-specific, see perlfunc/printf instead.
vprintf() is C-specific, see perlfunc/printf instead.
vsprintf() is C-specific, see perlfunc/sprintf instead.
wait() function,
see perlfunc/wait.
waitpid() function, see perlfunc/waitpid.
$pid = POSIX::waitpid( -1, POSIX::WNOHANG );
print "status = ", ($? / 256), "\n";
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.
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.
POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_WRONLY );
$buf = "hello";
$bytes = POSIX::write( $b, $buf, 5 );
Returns undef on failure.
See also perlfunc/syswrite.
POSIX::SigAction object which corresponds to the 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 POSIX::SigSet
object, it defaults to the empty set. The third parameter contains the
sa_flags, it defaults to 0.
$sigset = POSIX::SigSet->new(SIGINT, SIGQUIT);
$sigaction = POSIX::SigAction->new( \&main::handler, $sigset, &POSIX::SA_NOCLDSTOP );
This POSIX::SigAction object is intended for use with the POSIX::sigaction()
function.
$sigset = $sigaction->mask;
$sigaction->flags(&POSIX::SA_RESTART);
POSIX::SigAction object:
$sigaction->safe(1);
You may also examine the ``safe'' flag on the output action object which is
filled in when given as the third parameter to POSIX::sigaction():
sigaction(SIGINT, $new_action, $old_action);
if ($old_action->safe) {
# previous SIGINT handler used safe signals
}
Create an empty set.
$sigset = POSIX::SigSet->new;
Create a set with SIGUSR1.
$sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 );
$sigset->addset( &POSIX::SIGUSR2 );
Returns undef on failure.
$sigset->delset( &POSIX::SIGUSR2 );
Returns undef on failure.
$sigset->emptyset();
Returns undef on failure.
$sigset->fillset();
Returns undef on failure.
if( $sigset->ismember( &POSIX::SIGUSR1 ) ){
print "contains SIGUSR1\n";
}
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;
Obtain the attributes for stdin.
$termios->getattr()
Obtain the attributes for stdout.
$termios->getattr( 1 )
Returns undef on failure.
$c_cc[1] = $termios->getcc(1);
$c_cflag = $termios->getcflag;
$c_iflag = $termios->getiflag;
$ispeed = $termios->getispeed;
$c_lflag = $termios->getlflag;
$c_oflag = $termios->getoflag;
$ospeed = $termios->getospeed;
Set attributes immediately for stdout.
$termios->setattr( 1, &POSIX::TCSANOW );
Returns undef on failure.
$termios->setcc( &POSIX::VEOF, 1 );
$termios->setcflag( $c_cflag | &POSIX::CLOCAL );
$termios->setiflag( $c_iflag | &POSIX::BRKINT );
$termios->setispeed( &POSIX::B9600 );
Returns undef on failure.
$termios->setlflag( $c_lflag | &POSIX::ECHO );
$termios->setoflag( $c_oflag | &POSIX::OPOST );
$termios->setospeed( &POSIX::B9600 );
Returns undef on failure.
WIFEXITED($?) returns true if the child process exited normally
(exit() or by falling off the end of main())
WEXITSTATUS($?) returns the normal exit status of the child process
(only meaningful if WIFEXITED($?) is true)
WIFSIGNALED($?) returns true if the child process terminated because
of a signal
WTERMSIG($?) returns the signal the child process terminated for
(only meaningful if WIFSIGNALED($?) is true)
WIFSTOPPED($?) returns true if the child process is currently stopped
(can happen only if you specified the WUNTRACED flag to waitpid())
WSTOPSIG($?) returns the signal the child process was stopped for
(only meaningful if WIFSTOPPED($?) is true)