/ 
POSIX-1003-0.11
River stage one • 2 direct dependents • 2 total dependents
/ POSIX::1003

NAME

POSIX::1003 - POSIX 1003.1 extensions to Perl

INHERITANCE

POSIX::1003 is extended by
  POSIX::1003::Confstr
  POSIX::1003::Events
  POSIX::1003::FS
  POSIX::1003::FdIO
  POSIX::1003::Limit
  POSIX::1003::Locale
  POSIX::1003::Math
  POSIX::1003::OS
  POSIX::1003::Pathconf
  POSIX::1003::Proc
  POSIX::1003::Properties
  POSIX::1003::Signals
  POSIX::1003::Sysconf
  POSIX::1003::Termios
  POSIX::1003::Time

SYNOPSIS

# use the specific extensions
# and see POSIX::Overview and POSIX::3

DESCRIPTION

The POSIX module in core (distributed with Perl itself) is ancient, the documentation is usually wrong, and it has too much unusable code in it. POSIX::1003 tries to provide cleaner access to the operating system. More about the choices made can be found in section "Rationale",

The official POSIX standard is large, with over 1200 functions; POSIX::Overview does list them all. This collection of POSIX::1003 extension provides access to quite a number of those functions, when they are not provided by "core". They also define as many system constants as possible. More functions may get added in the future.

Start looking in POSIX::Overview, to discover which module provides certain functionality. You may also guess the location from the module names listed in "DETAILS", below.

Exporter

All modules provide a :constants and a :functions tag, sometimes more. The default is :all, which means: everthing. You may also specify :none (of course: nothing).

When the import list is preceeded by +1, the symbols will get published into the namespace of the caller namespace.

use POSIX::1003::Pathconf;
use POSIX::1003::Pathconf ':all';  # same
use POSIX::3 ':pc';                # same, for the lazy
use POSIX::3 ':pathconf';          # same, less lazy

sub MyModule::import(@)   # your own tricky exporter
{   POSIX::1003::Pathconf->import('+1', @_);
}

METHODS

POSIX::1003->exampleValue(NAME)

Returns an example value for the NAMEd variable. Often, this is a compile-time or runtime constant. For some extensions, like ::Pathconf, that may not be the case.

DETAILS

Modules in this distribution

POSIX::1003::Confstr

Provide access to the _CS_* constants.

POSIX::1003::FdIO

Provides unbuffered IO handling; based on file-descriptors.

POSIX::1003::FS

Some generic file-system information. See also POSIX::1003::Pathconf for more precise info.

POSIX::1003::Locale

Locales, see also perllocale.

POSIX::1003::Math

Standard math functions of unknown precission.

POSIX::1003::OS

A few ways to get Operating system information. See also POSIX::1003::Sysconf, POSIX::1003::Confstr, and POSIX::1003::Properties,

POSIX::1003::Pathconf

Provide access to the pathconf() and its trillion _PC_* constants.

POSIX::1003::Properties

Provide access to the _POSIX_* constants.

POSIX::1003::Signals

With helper modules POSIX::SigSet and POSIX::SigAction.

POSIX::1003::Sysconf

Provide access to the sysconf and its zillion _SC_* constants.

POSIX::1003::Termios

Terminal IO

POSIX::1003::Time

Time-stamp processing

POSIX::1003::Limit

For getting and setting resource limits.

Other modules

Fcntl

Flags for modes, seek and fcntl are left to be defined by the Fcntl module.

Errno

All constants representing error numbers are left to be defined in the Errno module.

User::pwent

Provides an OO interface around getpw*()

User::grent

Provides an OO interface around getgr*()

Unix::SavedIDs

provides access to all (get|set)e?[ug]id functions. Of course, you may use the special variables $( $) $< $> as well, but that gives unpredictable results.

Rationale

The POSIX module as distributed with Perl itself is ancient (it dates before Perl5) Although it proclaims that it provides access to all POSIX functions, it only lists about 200 out of 1200. From that subset, half of the functions with croak when you use them, complaining that they cannot get implemented in Perl for some reason.

Many other functions provided by POSIX-in-Core simply forward the caller to a function with the same name which is in basic perl (see perldoc). With a few serious complications: the functions in POSIX do not use prototypes, sometimes expect different arguments and sometimes return different values.

Back to the basics: the POSIX::1003 provides access to the POSIX libraries where they can be made compatible with Perl's way of doing things. For instance, setuid of POSIX is implemented with $), whose exact behavior depends on compile-flags and OS: it's not the pure setuid() of the standard hence left-out. There is no isalpha() either: not compatible with Perl strings and implemented very different interface from POSIX. And there is also no own exit(), because we have a CORE::exit() with the same functionality.

POSIX::1003 compared to POSIX

This distribution does not add much functionality itself: it is mainly core's POSIX.xs (which is always available and ported to all platforms). You can access these routines via POSIX as well.

When you are used to POSIX.pm but want to move to POSIX::1003, you must be aware about the following differences:

  • the constants and functions are spread over many separate modules, based on their purpose, where POSIX uses a header filename as tag to group provided functionality.

  • functions provided by CORE are usually not exported again by POSIX::1003 (unless to avoid confusion, for instance: is atan2() in core or ::Math?)

  • constants which are already provided via Fcntl or Errno are not provided by this module as well. This should reduce the chance for confusion.

  • functions which are also in CORE can be imported, but will silently be ignored. In POSIX, functions with the same name get exported without prototype, which does have consequences for interpretation of your program. This module uses prototypes on all exported functions, like CORE does.

  • hundreds of _SC_*, _CS_*, _PC_*, _POSIX_*, UL_*, and RLIMIT_* constants were collected from various sources, not just a minimal subset. You get access to all defined on your system.

  • when an user program addresses a constant which is not defined by the system, POSIX will croak. Modules in POSIX::1003 on the other hand, will return undef.

    This simplifies code like this:

    use POSIX::1003::FS         'PATH_MAX';
use POSIX::1003::PathConfig '_PC_PATH_MAX';
my $max_fn = _PC_PATH_MAX($fn) // PATH_MAX // 1024;

    With the tranditional POSIX, you have to eval() each use of a constant.

SEE ALSO

This module is part of POSIX-1003 distribution version 0.11, built on January 04, 2012. Website: http://perl.overmeer.net. The code is based on POSIX, which is released with Perl itself.

COPYRIGHTS

Copyrights of the perl code and the related documentation by 2011-2012 by Mark Overmeer. For other contributors see ChangeLog.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See http://www.perl.com/perl/misc/Artistic.html