| POSIX - Perl interface to IEEE Std 1003.1 |
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).
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 the perlfunc manpage 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 the perlsub manpage.
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 int in the perlfunc manpage.
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 int in the perlfunc manpage.
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 chdir in the perlfunc manpage.
chmod() function, allowing
one to change file and directory permissions, see chmod in the perlfunc manpage.
chown() function, allowing one
to change file and directory owners and groups, see chown in the perlfunc manpage.
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 close in the perlfunc manpage.
closedir() function for closing
a directory handle, see closedir in the perlfunc manpage.
cos() function, for returning
the cosine of its numerical argument, see cos in the perlfunc manpage.
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 sysopen in the perlfunc manpage 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 int in the perlfunc manpage 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 $ERRNO in the perlvar manpage.
execl() is C-specific, see exec in the perlfunc manpage.
execle() is C-specific, see exec in the perlfunc manpage.
execlp() is C-specific, see exec in the perlfunc manpage.
execv() is C-specific, see exec in the perlfunc manpage.
execve() is C-specific, see exec in the perlfunc manpage.
execvp() is C-specific, see exec in the perlfunc manpage.
exit() function for exiting the
program, see exit in the perlfunc manpage.
exp() function for
returning the exponent (e-based) of the numerical argument,
see exp in the perlfunc manpage.
abs() function for returning
the absolute value of the numerical argument, see abs in the perlfunc manpage.
IO::Handle::close() instead, or see close in the perlfunc manpage.
fcntl() function,
see fcntl in the perlfunc manpage.
IO::Handle::new_from_fd() instead, or see open in the perlfunc manpage.
IO::Handle::eof() instead, or see eof in the perlfunc manpage.
IO::Handle::error() instead.
IO::Handle::flush() instead.
See also $OUTPUT_AUTOFLUSH in the perlvar manpage.
IO::Handle::getc() instead, or see read in the perlfunc manpage.
IO::Seekable::getpos() instead, or see seek in the L manpage.
IO::Handle::gets() instead. Similar to <>, also known
as readline in the perlfunc manpage.
IO::Handle::fileno() instead, or see fileno in the perlfunc manpage.
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 open in the perlfunc manpage.
fork() function
for duplicating the current process, see fork in the perlfunc manpage
and the perlfork manpage 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 printf in the perlfunc manpage instead.
fputc() is C-specific, see print in the perlfunc manpage instead.
fputs() is C-specific, see print in the perlfunc manpage instead.
fread() is C-specific, see read in the perlfunc manpage instead.
free() is C-specific. Perl does memory management transparently.
freopen() is C-specific, see open in the perlfunc manpage instead.
($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
fscanf() is C-specific, use <> and regular expressions instead.
IO::Seekable::seek() instead, or see seek in the perlfunc manpage.
IO::Seekable::setpos() instead, or seek seek in the perlfunc manpage.
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 tell in the perlfunc manpage.
fwrite() is C-specific, see print in the perlfunc manpage instead.
getc() function,
see getc in the perlfunc manpage.
getc(),
see getc in the perlfunc manpage.
$(, see $EGID in the perlvar manpage.
%ENV array.
$>
variable, see $EUID in the perlvar manpage.
$), see $GID in the perlvar manpage.
getgrgid() function for
returning group entries by group identifiers, see
getgrgid in the perlfunc manpage.
getgrnam() function for
returning group entries by group names, see getgrnam in the perlfunc manpage.
$), see $GID in the perlvar manpage.
getlogin() function for
returning the user name associated with the current session, see
getlogin in the perlfunc manpage.
getpgrp() function for
returning the prcess group identifier of the current process, see
getpgrp in the perlfunc manpage.
$$, see $PID in the perlvar manpage.
getppid() function for
returning the process identifier of the parent process of the current
process , see getppid in the perlfunc manpage.
getpwnam() function for
returning user entries by user names, see getpwnam in the perlfunc manpage.
getpwuid() function for
returning user entries by user identifiers, see getpwuid in the perlfunc manpage.
STDIN, similar to <>, also known
as the readline() function, see readline in the perlfunc manpage.
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 $UID in the perlvar manpage.
gmtime() function for
converting seconds since the epoch to a date in Greenwich Mean Time,
see gmtime in the perlfunc manpage.
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 -X in the perlfunc manpage.
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 kill in the perlfunc manpage.
labs() is C-specific, see abs in the perlfunc manpage 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 link in the perlfunc manpage.
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 localtime in the perlfunc manpage.
log() function,
returning the natural (e-based) logarithm of the numerical argument,
see log in the perlfunc manpage.
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 die in the perlfunc manpage 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 index in the perlfunc manpage instead.
memcmp() is C-specific, use eq instead, see the perlop manpage.
memcpy() is C-specific, use =, see the perlop manpage, or see substr in the perlfunc manpage.
memmove() is C-specific, use =, see the perlop manpage, or see substr in the perlfunc manpage.
memset() is C-specific, use x instead, see the perlop manpage.
mkdir() function
for creating directories, see mkdir in the perlfunc manpage.
mkfifo() for creating
FIFO special files.
if (mkfifo($path, $mode)) { ....
Returns undef on failure. The $mode is similar to the
mode of mkdir(), see mkdir in the perlfunc manpage.
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 pack in the perlfunc manpage 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 sysopen in the perlfunc manpage.
$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 warn in the perlfunc manpage and $ERRNO in the perlvar manpage.
POSIX::open.
($fd0, $fd1) = POSIX::pipe();
POSIX::write( $fd0, "hello", 5 );
POSIX::read( $fd1, $buf, 5 );
See also pipe in the perlfunc manpage.
$x raised to the power $exponent.
$ret = POSIX::pow( $x, $exponent );
You can also use the ** operator, see the perlop manpage.
putc() is C-specific, see print in the perlfunc manpage instead.
putchar() is C-specific, see print in the perlfunc manpage instead.
puts() is C-specific, see print in the perlfunc manpage instead.
qsort() is C-specific, see sort in the perlfunc manpage instead.
$$ in $PID in the perlvar manpage.
rand() is non-portable, see rand in the perlfunc manpage 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 sysread in the perlfunc manpage.
readdir() function
for reading directory entries, see readdir in the perlfunc manpage.
realloc() is C-specific. Perl does memory management transparently.
unlink() function
for removing files, see unlink in the perlfunc manpage.
rename() function
for renaming files, see rename in the perlfunc manpage.
rewinddir() function for
rewinding directory entry streams, see rewinddir in the perlfunc manpage.
rmdir() function
for removing (empty) directories, see rmdir in the perlfunc manpage.
scanf() is C-specific, use <> and regular expressions instead,
see the perlre manpage.
$) variable, see $GID in the perlvar manpage, 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 eval in the perlfunc manpage.
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 the perllocale manpage.
$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 the perllocale manpage 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 $UID in the perlvar manpage, 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 die in the perlfunc manpage 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 eval in the perlfunc manpage.
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 sin in the perlfunc manpage. 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 sleep in the perlfunc manpage. 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 sprintf in the perlfunc manpage.
sqrt() function.
for returning the square root of the numerical argument,
see sqrt in the perlfunc manpage.
sscanf() is C-specific, use regular expressions instead,
see the perlre manpage.
stat() function
for retutning information about files and directories.
strcat() is C-specific, use .= instead, see the perlop manpage.
strchr() is C-specific, see index in the perlfunc manpage instead.
strcmp() is C-specific, use eq or cmp instead, see the perlop manpage.
strcoll()
for collating (comparing) strings transformed using
the strxfrm() function. Not really needed since
Perl can do this transparently, see the perllocale manpage.
strcpy() is C-specific, use = instead, see the perlop manpage.
strcspn() is C-specific, use regular expressions instead,
see the perlre manpage.
$!, see $ERRNO in the perlvar manpage.
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 length in the perlfunc manpage.
strncat() is C-specific, use .= instead, see the perlop manpage.
strncmp() is C-specific, use eq instead, see the perlop manpage.
strncpy() is C-specific, use = instead, see the perlop manpage.
strpbrk() is C-specific, use regular expressions instead,
see the perlre manpage.
strrchr() is C-specific, see rindex in the perlfunc manpage instead.
strspn() is C-specific, use regular expressions instead,
see the perlre manpage.
index() function,
see index in the perlfunc manpage.
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
the perlre manpage, or split in the perlfunc manpage.
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 the perllocale manpage.
The following will get the machine's clock speed.
$clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
Returns undef on failure.
system() function, see
system in the perlfunc manpage.
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 time in the perlfunc manpage.
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 lc in the perlfunc manpage, or the equivalent \L operator inside doublequotish
strings.
uc() function,
see uc in the perlfunc manpage, 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 umask in the perlfunc manpage.
($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 unlink in the perlfunc manpage.
utime() function
for changing the time stamps of files and directories,
see utime in the perlfunc manpage.
vfprintf() is C-specific, see printf in the perlfunc manpage instead.
vprintf() is C-specific, see printf in the perlfunc manpage instead.
vsprintf() is C-specific, see sprintf in the perlfunc manpage instead.
wait() function,
see wait in the perlfunc manpage.
waitpid() function, see waitpid in the perlfunc manpage.
$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 syswrite in the perlfunc manpage.
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)
| POSIX - Perl interface to IEEE Std 1003.1 |