Next: Qa-Qm Up: Linux Software Encyclopedia Previous: Pa-Pm Contents

Pn-Pz

Last checked or modified: Oct. 29, 1998

PNG: Portable Network Graphics is a format for portable graphics, as you might surmise from the name. PNG unofficially stands for PNG's Not GIF, which originates from the decision of Unisys and CompuServe to require royalties from programs using the GIF format since Unisys has a patent on the LZW compression format used therein. The main advantages which PNG has over GIF are:

alpha channels (variable transparency),

gamma correction (cross-platform control of image brightness), and

2-D interlacing (a method of progressive display).

It also compresses better in almost every case, with the difference generally ranging from 10% to 30%. Since PNG is intended to be single-image format only, it doesn't feature multiple-image support. PNG also has the advantage that it has one and only one official pronunciation, i.e. ``ping.''
Standard PNG features include:

support for three main image types, i.e. truecolor, grayscale, and palette (with JPEG supporting the first two and GIF only the third);

compression filters which are a way of transforming the image data (losslessly) so it will compress better; and

file integrity checks, e.g. an 8-byte magic signature at the beginning of every image, a 32-bit cyclic redundancy check, and an Adler-32 checksum applied to the complete stream of uncompressed data.

PNG-related software includes:

libpng, the PNG library;

gd,

gforge,

Ghostview,

GIMP,

Gnuplot,

ImageMagick,

PIL,

pngcrush,

xli,

xpaint and

xv.

Web browsers which support the PNG format include Amaya, Arena, Chimera, Grail, Mosaic, Netscape, and XEmacs.
[http://www.cdrom.com/pub/png/]
[http://www.hensa.ac.uk/png/home/]
[http://www.graphicswiz.com/png/]

libpng

A companion library to the PNG specification written to reduce the amount of time and effort it takes to support said specification. Libpng is designed to handle multiple simultaneous sessions, to be easily modifiable, and to be portable to most machines. It uses zlib for the compression and decompression of PNG files.
The source code for libpng, written in C, is available and should compile on most machines since that is a design goal. It is documented in an ASCII file included with the distribution.
[http://www.cdrom.com/pub/png/pngcode.html]

pngcrush

A batch-mode compression utility for PNG images. This reduces the size of the PNG datastream by trying various compression levels and filter methods.
[http://www.xnot.com/pmt/pngcrush/]
PNG Magick: See under the Netscape entry since this is a Netscape plug-in.
PNM: See Pbmplus.
Pnuts: A scripting language for the Java environment. It was designed to provide a simple interface to manipulate Java objects and to be called easily from Java programs, and is particularly useful for debugging and prototyping. The features of Pnuts include:

full access to all public members and constructors of the Jav API (although it lacks the capability of defining classes);

an expression-based (i.e. interpreted) environment;

integration of primitive and reference data types;

a pseudo list notation implemented as an array of objects;

functions that can take an arbitrary number of parameters and which are identified by the name and number of parameters;

no typing of variables, i.e. no declarations; and

packages that provide naming scopes.

A source code distribution is available which requires JDK 1.1 or better.
[http://www.etale.com/pnuts/]
POC: The Portable Object Compiler is described in the OBJC entry.
pod2ps: A program which takes one or multiple Perl POD files and produces a single PostScript file. It can be run on single or multiple files from the command line or using a script or command file. The output includes PDFMARK operators that can be used by the Adobe Acrobat Distiller program to produce a fully indexed PDF file.
[http://www.oasis.leo.org/perl/scripts/textproc/pod2ps.dsc.html]
Point: A text editor specifically designed to use the mouse as much as possible in editing. Point provides convenient ways to keep a number of windows open on files and to copy text between and within files using the mouse.
The features of Point include:

an unlimited number of windows and files;

easy moving and copying within and among windows;

complete configurability including menus, key bindings, titles, etc.;

extensive options for modifying the look and feel;

the use of Tcl/Tk as a macro language and graphical toolkit;

several searching options including for selection, last string searched for, a regular expression, the last regular expression, a string in a list of files, or a C tag;

file browsers;

circular mouse menus, i.e. gesture commands; and

unlimited undo, redo, and again.

A source code distribution of Point is available. It is written in C with compilation and use also requiring Tcl 7.0 or greater or Tk 3.3 or greater. It is documented in a user's guide available in PostScript format as well as in a man page. A brief FAQ is also included.
[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]
POISS: A package of Fortran 77 routines for the rapid solution of certain types of elliptic equations in rectangular and irregular domains. Specifically, solutions are found for the nonseparable self-adjoint elliptic problem in 2-D polygonal domains with Direchlet boundary conditions. Helmholtz and Poisson problems in polygonal domains and the general variable coefficient problem in a rectangular domain can be treated as special cases of this. The solution method combines the use of the capacitance matrix method (for treating the irregular boundary) and an efficient iterative method (using the Laplacian as a preconditioner) to deal with nonseparability. Each iterative step thus involves solving the Poisson equation in a rectangular domain. This is TOMS algorithm 732 and is documented in Cummins and Vallis (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
POLIS: A framework and package for the hardware-software co-design of embedded systems, especially those which are control-intensive, reactive, real-time systems. Examples of the types of systems for which POLIS is designed included microwave ovens, cameras, telephone switches, cellular phones, engine controllers, anti-lock brake controllers, robots, and plant monitors. The POLIS system is based around a single finite state machine-like (FSM) representation called a co-design finite state machine (CFSM). The CFSM transforms a set of inputs into a set of outputs with only a finite amount of internal state. It differs from FSMs in that the synchronous communication model of the FSM is replaced by a finite, non-zero, unbounded reaction time model in the CFSM. This model can be described as globally asynchronous and locally synchronous, with CSFM specifications a priori unbiased towards either a hardware or software implementation. The chief advantage of the abstract CFSM model is that is covers the behavior of all possible hardware-software implmentations at once.

In POLIS specifications are written in a high-level language such as Esterel that is directly translated into CFSMs. The formal specification and synthesis methodology uses many of the methods available for CSMs (e.g. VIS) which are applied via the inclusion of a translator from CFSMs to FSMs. The methodology also incorporates a set of abstraction and assumption rules specific to CFSMs and POLIS which makes is possible to verify designs larger than was previously possible. A co-simulation process is used which lets the designer test a wide range of choices for hardware/software partitioning and CPU and schedular selection, with the Ptolemy package currently used as a simulation engine. The portions of the CFSMs chosen for hardware implementation are optimized using logic synthesis techniques from the SIS package. The portions to be implemented in software are mapped onto a software structure which includes a procedure for each CFSM together with a simple real-time operating system. The reactive behavior of the CFSM portions is synthesized by first implementing and optimizing the desired behavior in a high-level, processor-independent form similar to a control/data flow graph, which is then translated into portable C code for further optimization on a given compiler. An application-specific OS consisting of a schedular and I/O drivers is generated for each partitioned design. The interfaces between the hardware and software domains are automatically synthesized within POLIS, and come in the form of cooperating circuits and software procedures embedded in the synthesized implementation.

A source code distribution of POLIS is available as are binaries for several platforms including Linux Intel. The source can be compiled on most UNIX flavors using the GCC compiler. The documentation includes a user's manual in PostScript format.
[http://www-cad.eecs.berkeley.edu/Respep/Research/hsc/abstract.html]
POLKA: A general purpose animation system particularly well-suited to building animations of programs, algorithsm, and computations (especially parallel computations). POLKA provides its own high-level abstractions to make the creation of animations easier and faster than with many other systems, with programmers not needing to be graphics experts to develop animations. It includes an interactive front-end called SAMBA which is an animation interpreter that reads ASCII commands or animation directives and performs them.
A source code distribution of POLKA is available. It is written in C++ on top of UNIX and X11 and requires either the Motif or Xaw widget sets. It is documented in a technical report available in PostScript format.
[http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html]
POLMAP: A Starlink Project package for the interactive data analysis of linear spectropolarimetric data. A linear polarization spectrum is a set of Stokes vectors which means that spectropolarimetric data is 4-D (and 6-D if the variance arrays of the Stokes parameters are included) and cannot be manipulated using standard spectral analysis packages. POLMAP is designed for the specific needs of these data sets.
TRIPLOT is a command for the flexible display of polarization spectra. It displays triplots which consist of a top panel showing the position angle of the polarization in degrees, a middle section showing the percentage polarization, and a bottom section showing the intensity spectrum. A polarization spectrum may also be plotted in the QU plane using the QUPLOT command. Other commands include MERGE to merge two stack polarization spectra, ISFIT to fit a Serkowksi law to the data using a nonlinear least squares method (in order to subtract the interstellar polarization vector from the intrinisic polarization spectrum), and FITPA and PACALIB for PA calibration.
A binary distribution of POLMAP is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. It is documented in a user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
PolRadTran: A plane-parallel fully-polarized atmospheric radiative transfer model. This package contains separate versions, one for solar or thermal radiation in a medium of randomly oriented particles and one for thermal radiation in a medium of azimuthally symmetrically-oriented particles. The codes are written in Fortran and documented in ASCII README files.
[http://nit.colorado.edu/~evans/polrad.html]
POLSYS_PLP: A Fortran 90 code for solving N complex coefficient polynomial systems of equations in N unknowns using a probability-one, globally convergent homotopy method. The package consists of two modules:

GLOBAL_PLP, contains the derived data types that define the polynomial system, the system partition, and the start system of the homotopy; and

POLSYS, contains the actual solver and its internal routines as well as the routines responsible for root counting.

This also requires some routines from HOMPACK90.
[http://www.netlib.org/opt/index.html]
PolyglotMan: A filter for UNIX man pages. It takes as input man pages formatted for a variety of UNIX flavors (not [tn]roff source) and produces as output a variety of file formats, e.g. ASCII, TkMan, [tn]roff, Ensemble, SGML, HTML, LaTeX, RTF, etc. This is written in ANSI C and should compile on any UNIX box with a C compiler, including Linux. This used to be called RosettaMan.
[http://www.cs.berkeley.edu/~phelps/tcltk/index.html]
Polynomial Toolbox: The latest version of this (version 2) is a commercial product, and no freely editions are available. A Matlab toolbox for performing many types of computations with and on polynomial matrices. The functionality of the toolbox includes:

defining polynomial matrices;

performing operations on polynomial matrices, e.g. transforming them to canonical forms such as Hermite, Smith, echelon, row, column and diagonally reduced forms;

computing determinants and zeros;

performing operations such as addition and multiplication;

performing spectral factorization and computing null spaces;

modeling linear time-invariant systems and transforming polynomial representations thereof to and from other representations;

solving linear polynomial matrix equations; and

solving various types of control problems such as pole placement, H-2 and H-infinity optimization.

Documentation is available in PDF format.
[http://www.math.utwente.nl/polbox/]
Poly3D: A C program implementing boundary elements to provide solutions to boundary value problems of continuum mechanics. Poly3D calculates the displacements and strains and stresses in an elastic whole- or half-space using planar, polygonal-shaped elements of displacement discontinuity. Polygonal elements may have any number of sides (with a minimum of three), and parameters are calculated at specified points or grids defined by the user. Model fractures and surfaces are treated as surfaces of displacement discontinuity (opening or slip). Slip distributions on faults subject to tectonic loading can be calculated as well as the stress and displacement fields around the faults.
[http://pangea.Stanford.EDU/geomech/Software/Software.htm]
POM: The Princeton Ocean Model is a sigma-coordinate, free surface, primitive equation ocean circulation model which includes a turbulence sub-model. It is written in Fortran 77 and is documented in a large manual in PostScript format.
[http://www.aos.princeton.edu/WWWPUBLIC/htdocs.pom]
POOMA: Parallel Object-Oriented Methods and Applications is an object-oriented framework for developing applications in computational science that require high performance parallel computers. It is implemented as a library of C++ clases designed to represent the common abstractions found in such applications. It is designed to achieve high performance on both single processor and shared-memory multiprocessor machines. This is accomplished by presenting the data parallel programming interface at the highest abstraction layer and encapsulating distribution and communication of data among processors in lower implementation layers. This means that codes developed on serial workstations port to all supported architectures.
The current (12/98) release provides multidimensional arrays using a wide variety of storage schemes and parallel decompositions, multithreading, and out-of-order execution for maximum performance. Planned features include fields, coordinate systems, particles, and parallelism on distributed memory multicompters and networks of workstations using MPI. See Reynders III (1998).
[http://www.acl.lanl.gov/pooma/]
POP (ocean): The Parallel Ocean Program ocean circulation model is a descendant of the Bryan-Cox-Semtner class of finite-difference models, with several improvements that improve both the computational performance and the physical accuracy. These include:

a formulation of the barotropic surface mode based on surface pressure (rather than the streamfunction) which allows any number of islands to be included at no additional computational cost as well as more realistic, unsmoothed bottom topoography to be used with no reduction in time step;

an implicit free-surface boundary condition that allows the air-sea interface to evolve freely and makes sea-surface height a prognostic variable;

latitudinal scaling of horizontal diffusion which prevents the time step from being severely limited at high latitudes while keeping diffusion large enough to maintain numerical stability;

pressure gradient computation via a linear combination of three time levels, allowing the time step to be increased;

use of domain decomposition in latitude and longitude as well as MPI for ease of use and increased efficiency on parallel machines;

use of general orthogonal coordinates in the horizontal, allowing alternatives to bypass the usual singularity at the North Pole; and

a displaced-pole grid that moves the singularity onto a land mass.

This is written in Fortran 90 and requires an appropriate compiler.
[http://www.acl.lanl.gov/climate/models/pop/]
POP: In systems using the Post Office Protocol mail is delivered to a shared server, with client programs periodically connecting to the server to download all pending mail. This is called a store-and-forward service that moves mail on demand from an intermediate server or drop point to single destination machines. The protocol is described in RFCs 1734, 1957, 2095, and 2195. See Johnson (2000).
Software capable of acting either as a POP mail server or client includes:

BlitzMail

fetchmail

fetchpop

getpop

Mutt

nmh

Popper

Ratatosk

UMT

XCmail

XFMail
Popper: An implementation of the Post Office Protocol (POP) which runs on a variety of UNIX computers to manage electronic mail for Mac and MS-DOS computers. The features of Popper include: an idle timeout, a bulletin board, statistics gathering, an xlst (extended list) command, an uidl (unique identifier list) command, Kerberos, shadow passwords, rpop, an authorization file, logging of mail sent via POP to mail debug, MMDF handling (autodetection), APOP authentication, large site support, i.e. a server mode, a database for bulletin tracking, and Kerberos enabled no enabelable by a switch.
A source code version of this is available with makefiles for many flavors of UNIX included. The package is documented in man pages. A shadow password version of this can be found in the Shadow Ina Box tool suite.
[http://sunsite.unc.edu/pub/Linux/system/mail/pop/]
PoPToP: A PPTP server that allows Linux servers to function seamlessly in a PPTP VPN environment. The current (5/99) release supports Windoze 95/98/NT clients and PPTP Linux clients. The eventual full release will support all Windows clients with a full range of encryption and authentication features.
[http://www.moretonbay.com/vpn/pptp.html]
Porch: A source-to-source compiler that translates C programs into those capable of saving and recovering from portable checkpoints. These checkpoints can be transferred in heterogeneous computer networks such as the Internet and may be restarted on binary incompatible machines. This has been successfully tested on several systems including Linux Intel.
[http://theory.lcs.mit.edu/~porch/]
PORT (Bell): The Portable, Outstanding, Reliable and Tested mathematical subroutine library is a large collection of mathematical subroutines written in Fortran. It covers most traditional areas of numerical mathematics except for statistics. In addition to the mathematical routines, there are several non-numeric routines that constitute what is called the Framework of the library. The Framework consists of error handling, memory stack allocation, and machine-constant specific routines that underly the mathematical routines and contain the platform specific features.
The mathematical routines of PORT are divided into several categories including:

approximation routines for performing best uniform approximation with rational splines, interpolation with splines, least squares approximation to discrete functions, and best uniform approximation to continuous functions;

differential equation routines for both stiff and nonstiff ODEs;

linear algebra software including eigenvalue routines, basic linear algebra modules, least squares routines, and linear equation solving programs;

optimization routines for minimizing functions with one or more variables;

partial differential equations in one spatial variable and time;

quadrature programs for performing numerical integrations;

root finding programs for finding zeros of polynomials, single real roots of functions, single roots of complex functions, and roots of a set of nonlinear equations;

special functions including all elementary functions defined in the ANSI 66 Standard Fortran Library, Bessel functions, and the gamma function;

fast Fourier transforms; and

utility functions including random number generators, arithmetic utilities, functions for evaluating expressions in terms of orthogonal polynomials, operations on 1-D arrays, and printing functions.

A source code distribution of the PORT library is available under a limited use non-commercial license. It is written in Fortran. Documentation is available in PostScript format.
[http://www.bell-labs.com/project/PORT/]
PORT (Netlib): A library of Fortran routines for performing various optimization tasks. The full PORT3 library is a commercial product available from Lucent Technologies, although a subset of the routines is publicly available. An important part of the subset is a set of three subroutines which handle machine dependencies for integers, real numbers, and double precision numbers and which are called, respectively, i1mach, r1mach, and d1mach. The subset also includes aoxtrp, d0xtrp, dalloc, dxtrap, e9rint, enter, entsrc, eprint, erroff, i0tk00, i0tk01, i8save, i8tsel, ialloc, istkgt, istkin, istkmd, istkqu, istkrl, istkst, leave, movebc, movebd, movebi, movebl, movebr, movefc, movefd, movefi, movefl, movefr, mtstak, n5err, nerror, nirall, retsrc, s88fmt, setc, setd, seterr, seti, setl, setr, srecap, stinit, and xtrap.
Also available in the public version of PORT are up-to-date versions of NL2SOL as well as extended variants, i.e. n2f, a version of NL2SNO; n2g, a version of NLSSOL; n2p, a variant of NLSOL that allows the residual vector and Jacobian matrix to be passed in piece rather than all at once; n2[fgp]b, versions of NL2SOL that handle simple bounds; ns[fg], versions for separable nonlinear least squares; ns[fg]b versions for separable nonlinear least squares with simple bounds; and dn[s2][fgp][b ], double precision versions of the above. There are also versions of the SMSNO, SUMSL, and HUMSL algorithms for general unconstrained minimization, e.g. mnf, which uses function values only; mng, which uses function and gradient values; mnh, which uses function, gradient, and Hessian values; mn[fgh]b, versions of the above which handle simple bounds; and dmn[fgh][b ], double precision versions of the above.
[http://www.netlib.org/port/]
port numbers: Special or reserved port numbers are assigned to various Internet protocols or services. For example, port 80 is almost always reserved for HTTP, port 0 for TCP and UDP, and port 119 for NNTP. Many of the numbers from 0 to 1023 are reserved in this way, with quite a few more so-called Registered Ports existing in the range 1024 to 65535. See the lists of:

Well Known Port Numbers
[http://www.con.wesleyan.edu/~triemer/network/docservs.html]

Registered Port Numbers
[http://www.con.wesleyan.edu/~triemer/network/regports.html]

[http://www.faqs.org/rfcs/rfc1700.html]
PORTA: The POlyhedron Representation Transformation Algorithm package is a collection of optimization routines for analyzing polytopes and polyhedra given either as the convex hull of a set of points (plus the convex cone of a set of vectors) or as a system of linear equations and inequalities. PORTA guarantees correct numerical results since only integer operations are performed. If an arithmetic overflow occurs using integer arithmetic then the computations are restarted using double precision integer arithmetic.
The programs in the package include:

traf, which performs a transformation from one of the two representations to the other using a Fourier-Mortzkin elimination algorithm which projects a linear system onto subspaces;

vint, which enumerates all of the valid integral points within given bounds;

fctp, which checks the facet inducing property of a set of linear inequalities for a polyhedron given as a convex hull plus a convex cone;

dim, which computes the dimension of a polyhedron given as a convex hull plus a convex cone; and

portsort, which sorts and formats given system to improve the readability of datafiles.

A source code distribution of PORTA is available. It is written in C and is documented via man pages.
[http://www.zib.de/Optimization/Software/Porta/]
PortScanner: A program that scans TCP ports. The features include strobe-scanning support for faster scanning of standardized network services and subnet scanning to iteratively scan for ports on all machines on a subnet simulteneously. A source code distribution is available.
[http://www.ameth.org/~veilleux/portscan.html]
PortSentry: A system for port scan detection and active defense. This part of the Abacus Project suite of security tools is designed to detect and respond to port scans against a target host in real time. The novel features of PortSentry include:

configurability to run on multiple, simultaneous TCP and UDP sockets so one copy can cover dozens of tripwired services;

stealth scan detection, e.g. detection of SYN/half-open, FIN, NULL, X-MAS and oddball packet stealth scans;

reaction to port scan attempts by blocking the host in real time via either dropping the local route back to the attacker or dropping the attacking host IP into a TCP Wrappers hosts.deny file;

an internal state engine to remember previously connected hosts; and

reporting all violations to local or remote syslog daemons including the system name, time of attack, attacking host IP, and hte port through which the attempt was made.

A source code distribution is available.
[http://www.psionic.com/abacus/portsentry/]
POSES++: A software tool for modeling and simulating arbitrary discrete and discontinuous systems. It can also handle suitably discretized continuous systems. POSES++ supports the analysis of existing or planned systems and optimizes them by creating various variants of the system and comparing their performance. It can also be used to generate complex control software by creating a model containing the optimal algorithms for controlling a system, and then creating a binary version of that model for the actual system being modeled. The modeling is based on high level Petri Net definitions. POSES++ can most obviously be applied to the field of logistics, i.e. the safeguarding of investment decisions, the shortening of development cycles, the optimization of such systems, etc.
The POSES++ system consists of several components which each offer flexible and extensible interfaces to other POSES++ tools as well as to external software. The collection of tools comprises a multiserver-multiclient structure whose components communicate using TCP/IP via a command-line interface. The components include:

an Editor used to generate and process models based on a modular design concept with each model capable of being used independently or as a sub-model of some larger model;

a Compiler that checks the syntactic correctness of the source file and then uses it to generate the model needed by the simulation kernel for evaluation of the rules which can also create efficient binary codes for varous hardware and software combinations which represents the executable simulation model;

an Animator and Layout Editor which are used to generate graphical animations of system processes;

a Simulation Kernel which executes the simulation models created by the Compiler and handles necessary communication with the other components; and

an Experiment Tool which supplies the functions needed to execute simulation experiments, e.g. contacting the simulation kernel, selecting the desired model, handling debugging and tracing, etc.

External evaluation tools such as spreadsheets or math packages can also be used by POSES++ via an appropriate interface.
Binary distributions of POSES++ are available for DEC OSF/1, Sun SunOS, HP-UX, and Linux Intel platforms. A user's manual is available in either PostScript or HTML format.
[http://www.tu-chemnitz.de/ftp-home/pub/Local/simulation/poses++/www/]
POSIX: The Portable Operating System Interface is a set of operating system standards. It is an attempt by a consortium of vendors to create a single standard version of UNIX and is intended to define an operating system which behaves like UNIX whether or not it really is UNIX. The POSIX.1 standard defines the System Application Program Interface, i.e. the C procedure calls used in writing programs for UNIX. The POSIX.2 standard defines the Shell and Utilities and is heavily dependent on POSIX.1.
The POSIX.2 standard is the one which will be used to implement user-level commands. The major aspects defined by the POSIX.2 standard are: the Execution Environment Utilities, e.g. cat, kill, etc.; the User Portability Utilities, e.g. more, vi, etc.; the Software Development Utilities; the C Development Utilities; the shell command language; language-independent interfaces for high-level programming languages; and definitions, general requirements, and the UNIX environment, i.e. locales, guidelines for utility command-line syntax, system-wide environment variables, and regular expressions.
The complete POSIX standards (as of 6/97) are (where a designation of the form POSIX.n is short for IEEE 1003.n):

POSIX.0 - guide to POSIX (+)

POSIX.1 - system API for the C language (+)

POSIX.1a - system API extensions (e.g. symlinks, etc.)

POSIX.1b - real-time and I/O extensions (formerly POSIX.4) (-)

POSIX.1c - threads (formerly POSIX.4a) (-)

POSIX.1d - more real-time extensions (formerly POSIX.4b)

POSIX.1e - security extensions and ACLs (formerly POSIX.6)

POSIX.1f - transparent network file access (formerly POSIX.8)

POSIX.1g - protocol independent communications and sockets (formerly POSIX.12)

POSIX.1h - fault tolerance

POSIX.1i - technical corrections to POSIX.1b (-)

POSIX.1j - advanced real-time extensions

POSIX.1k - removable media API

POSIX.1m - checkpointing and restarting

POSIX.1n - fixes to .1, .1b, .1c and .1i

POSIX.1q - tracing

POSIX.2 - shells and common utility programs (+)

POSIX.2a - more tools and utilities (-)

POSIX.2b - more utilities

POSIX.2c - security utilities

POSIX.2d - batch processing utilities (-)

POSIX.2e - removable media utilities

POSIX.5 - Ada binding to POSIX.1 (+)

POSIX.5b - Ada binding to POSIX.1b (-)

POSIX.5c - Ada binding to POSIX.1g

POSIX.9 - Fortran 77 binding to POSIX.1 (+)

POSIX.10 - supercomputing profile (+)

POSIX.13 - realtime profile

POSIX.14 - multi-processing profile

POSIX.18 - POSIX profile

Other POSIX standards which follow a slightly different numbering system are:

IEEE 1387 - system administration

IEEE 1387.1 - overview

IEEE 1387.2 - software administration (+)

IEEE 1387.3 - user/group account administration (+)

IEEE 1387.4 - printer administration

IEEE 2003 - test methodology (formerly POSIX.3)

IEEE 2003.1 - test methods for POSIX.1

IEEE 2003.1b - test methods for POSIX.1b

IEEE 2003.2 - test methods for POSIX.2

Finished and published standards are marked with (+), extensions which have been included in the latest edition of the corresponding main standard are marked with (-), and all others are in the draft stage. Changes in POSIX standard status are announced in comp.std.unix, and the current status can be viewed at the first given URL. See Zlotnick (1991), Lewine (1991), and Gallmeister (1995).
[http://www.pasc.org/standing/sd11.html]
[http://www2.echo.lu/oii/en/api.html]
posix1b: A library containing implementations of some of the functions defined in the POSIX.1b standard that aren't as yet (12/98) present in Linux. These include clock, realtime timer, semaphore, shared memory and message queue functions. The timers are emulated using the BSD interval timer API and the other functions via standard System V IPC.
[http://www.ispras.ru/~knizhnik/]
POSSL: Panther Open Source Software for Linux is an application development environment for building transactional, component-based web applications. Its extensible framework decreases the technical complexity of building distributed applications by providing visual tools, an object repository and application building blocks. The features include:

an import utility to automatically create application objects from database tables;

a screen wizard for generating complex data access forms;

database drivers for automated result set management, data mapping between user interface and databse, and integration with database metadata;

a transaction manager for automatically generated SQL, managed application modality, and optimized SQL including that for multi-table joins and outer joins;

an EJB component builder for drag-and-drop building of components and automatic generation of component interfaces;

team development, debugging, version control and advanced reporting support; and

a class library of pre-built classes, methods and components to jumpstart application development.

The Panther framework provides all the tools nedded for building n-tier client/server applications. The development tools include:

a graphical editing environment for creating screens, reports and service components (specifically EJBs) using widgets such as pushbuttons and data entry fields;

a visual object repository consisting of a central library for creating, storing and accessing objects used for building applications;

a library facility for storing all the objects used in an applications;

a menu bar editor for designing menu bars and toolbars;

a testing environment and built-in debugger; and

a networked library and repository access for cohesive and controlled software development, including repository-stored application objects, interfaces to third-party source control, and access to libraries on remote machines.

The available deployment tools include:

programming language options including the Panther scripting language (JPL), Java or C for adding programming logic to screens, service components and reports;

a styles editor for assigning styles that define an object's color and protection based on the current transaction.

Tools for database access and support include:

drivers for several database engines;

the ability to import database definitions into a repository;

a single-user JDB SQL database for use as a prototyping tool for testing and refining multi-user database applications; and

a runtime transaction manager that performs the processing needed to view and update database information.

Tools for middleware access and support include:

a middleware adapter for connecting the middleware that manages communication between the client and server so the data can be passed from client to middleware, middleware to server, and back again;

the capability of creating service components (i.e. EJBs) to communicate with the IBM WebSphere software; and

runtime support for integration with WebSphere.

[http://www.possl.org/]
Possum: A mathematical tool for the representation and manipulation of finite partially ordered sets (i.e. posets). Possum is designed especially for providing tools for domain theory and the construction of approximations to semantic domains, but can be useful to anyone with an interest in order theory. It can produce Hasse diagrams of the posets that it generates via interaction with the daVinci visualization system. The diagrams are displayed on the screen and can be interactively fine-tuned. They can also be exported as PostScript for printing. Interaction is either through the daVinic GUI or a command-line interpreter which uses the Objective Caml language. The latter allows complicated expressions involving posets to be input concisely.
A source code distribution of Possum is available. Installation requires daVinci 2.0.3 or later and Objective Caml 1.05 or later. The use of the program is documented in several online HTML documents and the algorithms used in a technical report available in PostScript format.
[http://www.comlab.ox.ac.uk/oucl/groups/logfound/possum/index.html]
poster: A program for scaling and tiling a PostScript image for printing on multiple pages. Poster can be used to create a large poster by building it from multiple pages and/or printing it on large media. A source code distribution of this C program is available. It is documented via a man page.
[ftp://ftp.es.ele.tue.nl/pub/other/poster/]
Postfix: An MTA intended as a replacement for sendmail. Postfix attempts to be fast, easy to administer, and secure as well as compatible enough with sendmail to not upset existing users. The features of Postfix include:

performance up to three times as fast as its nearest competitor;

behaving rationally under stressful conditions, e.g. if the system runs out of disk space or memory it backs off rather than make the problem worse;

flexibility via a dozen or so programs that each perform only one specific task robustly and efficiently;

security via multiple layers of defense to protect the system against intruders;

eventual support for multiple transports although the initial release only handles SMTP with some support for UUCP;

support for virtual domains such that adding support for one requires changing only a single lookup table;

UCE control wherein Postfix can restrict what hosts can relay mail through it, and support for restrictions on what mail is allowed to enter; and

extensive use of table lookups rather than the implementation of an address rewriting language.

Several daemons are used by Postfix including:

master, the resident daemon that runs the other daemons on command in a manner similar to inetd with network processes;

smtpd, the SMTP server;

smtp, the SMTP client;

bounce, the message bouncing or deferring daemon;

pickup, the daemon that waits for hints the new mail has been dropped into the maildrop directory;

qmgr, the queue manager daemon that waits for the arrival of incoming mail and arranges for its delivery;

trivial-rewrite, a daemon that handles requests to rewrite and resolve addresses;

local, a daemon that processes delivery requests from the queue manager to deliver mail to local recipients; and

cleanup, a daemon to canonicalize and enqueue inbound mail.

Postfix contains several command-line programs for performing various tasks including:

sendmail, a Postfix to sendmail compatibility interface;

mailq, lists the mail queue;

newaliases, initializes the alias database;

postfix, controls the operation of the mail system;

postalias, maintains alias databases (and is used by newaliases);

postcat, displays the contents of queue files;

postconf, displays the main configuration file parameters;

postdrop, the mail posting agent run by the sendmail command on systems with no world-writable maildrop queue directory;

postkick, makes internal communication channels available for use in, e.g. shell scripts;

postlock, provides mailbox locking;

postlog, provides logging;

postmap, maintains lookup tables; and

postsuper, maintains the Postfix queue.

Source code distributions of Postfix are available as both stable official releases and experimental releases. Documentation is mostly via man pages.
[http://www.postfix.org/]
PostgreSQL: An enhancement of the POSTGRES database management system (DBMS), a next-generation DBMS research prototype. PostgreSQL retains the data model and data types of POSTGRES while replacing the PostQuel query language with an extended subset of SQL. Other enhancements include a program (psql) which supports GNU readline, a new front-end library (libpgtcl) which supports Tcl-base clients, a sample shell (pgtclsh) which provides new Tcl commands to interface Tcl programs with the PostgreSQL backend, a major overhaul of the large object interface, and more.
The features of PostgreSQL that distinguish it from conventional data managers include:

inheritance, i.e. a class can inherit from zero or more other classes and a query can reference either all instances of a class or all instances of a class plus all of its descendants;

time travel, i.e. a feature that allows a user to run historical queries by specifying a time range; and

non-atomic values, i.e. attributes can themselves contain sub-values that can be accessed from the query language, e.g. you can create attributes that are arrays of base types.

The source code for PostgreSQL, written in C, is available and can be compiled using gcc. It has been successfully tested on DEC Alpha, DEC Ultrix, Sun SunOS and Solaris, HP/9000, and Linux Intel platforms. An article about PostgreSQL can be found in the February 1998 issue of the Linux Journal.
[http://www.PostgreSQL.org/]

GtkSQL

A graphical database query tool developed using GTK and PostgreSQL.
[http://www.multimania.com/bbrox/GtkSQL/]

PgAccess

A free database management tool for PostgreSQL. The functionality includes:

opening multiple tables for viewing;

column resizing;

text wrap in cells with the layout saved for every table;

importing from and exporting to external files;

filtering and sorting;

editing in place;

a table generator assistant;

defining, editing and storing user-defined queries;

storing queries as views;

execution of queries with optional input parameters;

query deleting and renaming;

a visual query builder with drag and drop capabilities;

defining, inspecting and deleting sequences and functions in SQL;

designing and displaying simple reports from tables;

saving and loading report descriptions from a database;

a form design module;

defining, modifying and calling user-defined scripts; and

defining and modifying user parameters.

Source and binary distributions are available.
[http://www.flex.ro/pgaccess/]

PoPy

A PostgreSQL driver for Python.
[http://popy.sourceforge.net/]

PyGreSQL

A Python module that interfaces to a PostgreSQL database. It is object-oriented, easy to use, and has several extensions for building GUIs and interfacing with the Web.
[http://www.druid.net/pygresql/]
POSTIE: A mail user agent (MUA) called the ``swiss-army-knife of command-line mailers'' by its author. The features of POSTIE include:

sendmail compatibility for input streaming;

multipart file attachment/extraction;

sending and receiving HTML mail;

support for file-based mailing lists;

inter-host mail relaying;

mailbox masquerading wherein multiple users transparently share a single mail account;

Usenet news posting;

file attachment via wild card file specifications;

NNTP authentication support;

list server processing, i.e. creating public or private mailing lists;

file server processing, i.e. fetching files via email;

uuencoding/decoding of files and attachments;

IMAP4 support including posting;

embedding objects in HTML mail; and

SSLv3 and TLSv1.

A source code distribution of this C++ program is available as are binaries for selected platforms including Linux Intel. This is free for personal use.
[http://www.ozemail.com.au/~adavison/ipostie.html]
Postilion: A mail user agent based on TkRat with the addition of several features including robust support for IMAP in a shared folder environment. This uses IMAP mailboxes to support multiuser environments with system-wide configurations, mailboxes and address books, and shared folders. The source code distribution requires Tcl/Tk 8.0p2 as well as several common image libraries.
[http://www.postilion.org/]
PostScript: A programming language optimized for printing graphics and text. It is a page description language wherein individual pages or images are described in a device independent manner within the source code. It is also a stack-based language, resembling an RPN calculator (e.g. the HP series). A good introduction to the language and its operators is A First Guide to PostScript which is available in both hypertext and PostScript formats. There is also a PostScript Tutorial and Reference in PostScript format.
Useful resources include:

PostScript FAQ
[http://www.smartpages.com/faqs/postscript-faq/top.html]

PostScript Sources FAQ
[http://www.smartpages.com/faqs/postscript/top.html]

PostScript Corner
[http://www.unizh.ch/ps/PScorner.html]

Thinking in PostScript
[http://www.rightbrain.com/pages/books.html]

PostScript Programming Tutorial
[http://devcentral.iftech.com/learning/tutorials/misc/ps/]

Useful PostScript-related software includes:

a2ps, which converts ASCII text into PostScript and sends it to a printer or a file;

Distillery, which ensures that a PostScript document follows the Adobe DSC.

dvips, a program that converts TeX .DVI files into PostScript files;

enscript, which converts text files to PostScript;

epssplit, splits an EPS file into several smaller EPS files;

fontutils, which can convert PostScript fonts to TeX TK format;

Ghostscript, an interpreter;

Ghostview, a previewer;

Groff, which converts troff source into PostScript;

hp2xx, for converting HP-GL graphics into PostScript;

ImageMagick, an image conversion package;

impose++, a set of programs for printing two-up versions of PostScript files;

Lout, a typesetting system;

poster, for creating multiple page posters;

PPST, a benchmarking program for PostScript printers;

PreScript, a PostScript to plain text converter which can also produce rudimentary HTML;

PSPLOT, a library of Fortran-callable routines for creating PostScript graphs;

psrepair, for repairing common defects in PostScript files;

pstoedit, which converts PostScript and PDF files into other vector graphics formats;

pstoepsi, for converting PostScript into Encapsulated PostScript;

pstotext, which converts PostScript files into ASCII text files;

PSTricks, a collection of macros compatible with most TeX macro packages;

psutils, a set of utilities for resizing and various other tasks;

Quikscript, a portable typesetting system written in PostScript;

TinyDict, for PostScript processing that typesets ASCII text into various formats for self-printing books on laser printers; and

Zone, a library of 3-D PostScript operators.

The October 1997 issue of the Linux Journal contains an article about PostScript.
[http://www.ncf.carleton.ca/~cj434/]
POV-Ray: The Persistence Of Vision Raytracer creates 3-D, photo-realistic images using a rendering technique called ray tracing. It reads in a text file containing information describing the objects and lighting in a scene and generates an image of that scene from the view point of a camera also described in the text file. It can also add greater realism to images via a process known as radiosity. It produces very high quality images with realistic reflections, shading, perspective and other effects. The file containing the scene image description cannot be created with the POV-Ray package. This must be done with a separate package called a modeler] that allows you to visually arrange structures.
The features of POV-Ray include:

an easy to use description language;

a large library of example scene files;

standard include files that pre-define many shapes, colors and textures;

high quality output image files in 24-bit color;

creation of landscapes using smoothed height fields;

spotlights for sophisticated lighting;

phong and specular highlighting for more realistic looking surfaces;

many basic shape primitives;

Constructive Solid Geometry for easily combining simple shapes into complex shapes;

many built-in color patterns, surface bump patterns, and textures; and

combinations of textures.

A generic UNIX source code version is available as well as binary versions for Linux, DOS, Mac and Amiga platforms. The documentation is available in both HTML and PostScript formats. Also available are ancillary packages such as PVMPOV for distributing calculations across several platforms.
[http://www.povray.org/]

distpov

A program that allows POV-Ray to distribute rendering tasks across many machines. This connects to each machine, sends an archive containing all the files needed to render a scene, and tells each machine to do a small piece of the image. The features include:

a curses-based progress display on the server machine;

handling more than one job simultaneously;

dynamicallly adding and removing machines;

server state saving so the job can be stopped and started at any time; and

a UDP heartbeat signal for detecting whether machines are down.

A source code distribution is available.
[http://www.cus.umist.ac.uk/~ivarch/linux/distpov.html]

povfront

A front-end for POV-Ray that aims to provide an easy way to launch POV rendering with a graphical interface that manages all of the available options, including those that are ostensibly script-only. This is part of the GIRAM project.
[http://perso.club-internet.fr/clovis1/]

VisualPOV

A graphical interface for POV-Ray created using Tcl/Tk. The components include a toolbar for launching applications, a text editor specializing in the POV-Ray language, a tool for visualizing colors, and a window for changing rendering options.
[http://perso.easynet.fr/~philhay/projet.us.html]
PowerShell: A terminal emulator that supports many terminal windows embedded into a single X11 window, with each given its own notebook tab. The features include:

full GNOME support;

menu options to open a new tab with various programs running;

changing menu options via .pshellrc as well as via the preferences dialog box;

switching terms via CTRL-1, CTRL-2, etc.;

support for transparency and pixmap backgrounds;

full support for color; and

URL handling.

[http://rush.baked.net/~spong/powershell/]
PPBB-Lib: The Portable Parallel Branch-and-Bound Library offers an easy way to parallelize sequential branch and bound algorithms for several architectures. No knowledge of hardware architecture or parallelization mechanisms is needed to use PPBB-Lib. Each parallel running process of the B&B application maintains the point of view of the sequential algorithm, with the library taking over the management of the subproblems creating during execution. Load balancers provided by the library ensure a balanced distribution of the subproblems. It is designed to run on an distributed memory multicomputer architecture using the given message passing functions and a C compiler.
Binary versions of PPBB are available for both sequential and shared memory Linux Intel platforms as well as for several supercomputer platforms. It is documented in a user's manual available in PostScript format. It can be obtained by filling in an online request form.
[http://www.uni-paderborn.de/fachbereich/AG/monien/SOFTWARE/PPBB/]
PPCR: The POSIX Portable Common Runtime package provides integrated user-level support for pre-emptive lightweight threads, garbage collected storage, and dynamic program loading. PPCR can take advantage of kernel thread extensions in the underlying system and should run on any POSIX.1-conforming implementation which also supports BSD select() or System V poll(). It also uses memory protection features available in some systems to support incremental garbage collection.
The source code is available and has been successfully built on Sun SunOS and Solaris, SGI IRIX, Linux Intel, and BSDI platforms. PPCR is documented in an ASCII file in the distribution.
[ftp://ftp.parc.xerox.com/pub/ppcr/]
pPCx: The parallel predictor-corrector package is a parallel version of the PCx package. The source code is written in C with MPI extensions and should be released soon (4/97).
[http://www.cs.cornell.edu/Info/People/mwagner/pPCx/pPCx2.html
ppdd: An advanced encrypted file system for Linux Intel platforms. It is used in a manner similar to the loop device and offers simplicity, speed and full strength 128-bit encryption. A combination of master/working pass phrases offers enhanced security for backup copies. The latest version allows root filesystem encryption to ensure that no plaintext data is left on the disc. This is currently (1/99) in beta test stage and consists of a kernel patch plus some support programs.
[http://pweb.de.uu.net/flexsys.mtk/]
PPI++: The Parallel Portability Interface in C++ is an object-oriented message-passing library. It is designed to serve as a stable interface between the client parallel code and the rapidly evolving distributed computing environments. By taking advantage of encapsulation, inheritance, and polymorphism supported by C++, PPI++ provides a clean and consistent programming interface which helps improve the clarity and expressiveness of client parallel codes and hides implementation details and complexity from the user to ease parallel programming tasks. To benefit fully from the functionalities, portability, and efficiency provided by MPI, the present implementation of PPI++ uses MPI functions to achieve interprocess communication and synchronization. However, the C++ user interface of PPI++ is designed to be very light weight and independent of MPI.
The source code for PPI++, written in C++, is available. The package is documented in several technical reports available in PostScript format and also in Hsieh and Sotelino (1997).
[http://dalmatians.ecn.purdue.edu/~sesde/]
PPM: Abbreviation for the Portable PixelMap graphics format. This is used in the Pbmplus package.
ppmake: A parallel make utility which attempts to run as many parts of a large set of make jobs simultaneously on different computers connected by PVM as is possible. Ppmake requires on changes in makefiles, and can be used as easily as starting PVM on each participating computer and typing ppmake instead of make. The features include interrupt handling, setting timeouts, setting prefix commands, counting jobs, and calculation and display of the degree of parallelism. The ppmake software is available as source code. It's use requires GNU make as well as PVM.
[http://www3.informatik.tu-muenchen.de/~zimmerms/ppmake/]
ppm2fli: A conversion program which converts PPM, PGM, and PBM pictures into FLI animations and vice-versa. This is supposed to be a replacement for fbm2fli.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
PPP: The Point-to-Point Protocol is an Internet standard protocol for the transmission of IP packets over serial (e.g. modem lines. It is designed for simple links transporting packets between two peers with the links providing full-duplex simultaneous bi-directional operation. The three main components of PPP are: (1) a method for encapsulating multi-protocol diagrams; (2) a link control protocol (LCP) for establishing, configuring and testing the data-link connection; and (3) a family of network control protocols (NCP) for establishing and configuring different network layer protocols.

PPP-related software includes:

diald, a dialing daemon for Internet connections;

eznet, a program that automatically sets up and runs PPP;

EzPPP, a Qt front-end to PPP;

gppp, a GTK front-end to PPP;

IsinGlass, a script for making PPP connections more secure;

masqdialer, a daemon for initiating and terminating dialup Internet connections;

pppd, a PPP daemon package;

Visual PPP, a Tcl/Tk front-end to PPP.

[http://cs.uni-bonn.de/ppp/faq.html]
[http://sunsite.unc.edu/pub/Linux/system/network/serial/ppp/]
pppd: A package for implementing PPP. The package consists of two parts:

kernel code that establishes a network interface and passes packets between the serial port, the kernel networking code, and the daemon;

the daemon (pppd) that negotiates with the peer to establish the link and set up the PPP network interface.

The daemon also includes support for authentication. A source code distribution is available which is also included in most standard distributions.
[http://sunsite.unc.edu/pub/Linux/system/network/serial/ppp/]
[ftp://cs.anu.edu.au/pub/software/ppp/]
PPR: A UNIX print spooler designed for operating PostScript printers. PPR is a research project designed to explore the possibilities of the Adobe Document Structuring convention, PPD files, and automatic filtering with the goal of making printing easy for end users.
The features of PPR include:

operation of printers connected to parallel and serial ports, AppleTalk, LAN Manager X clients, LPD servers, and RAW TCP/IP adapters;

capture of messages returned by the printer while a job is printing (if the printer interface supports it);

sending notices to users when jobs are completed or when they fail;

detection of printer faults and automatic attempts to clear them;

interpretation of Document Structuring Convention (DSC) comments to support advanced features such as printer redirection, reverse order printing, collated copies, font downloading, font substitution, and forced duplex mode;

passing print jobs through Ghostscript before sending them to print PostScript files on non-PostScript printers;

automatic detection of non-PostScript output and passage through appropriate filters (e.g. Netpbm, TeX, and Groff);

automatic detection and decompression of compressed files;

printer queue advertising on AppleTalk networks;

accepting jobs for AT&T's LAN Manager for UNIX;]

acceptance of jobs from other computers using the LPD protocol and from the Samba LAN manager;

display of job percentage done in the queue listing; and

printing banner pages.

The code is currently being developed on a Linux system and has also been tested on DEC OSF/1, SGI IRIX, *BSD, and Sun SunOS platforms. The documentation includes installation and user's manuals (available in PostScript and HTML format) and an extensive set of man pages.
[http://ppr-dist.trincoll.edu/printing/pprfaq.html]
PPPui: A GUI for PPP created using Tcl/Tk.
[http://www.teleport.com/~nmeyers/PPPui/]
PPST: A PostScript printer benchmarking program. This tests a printer for the various things it's supposed to do and creates a set of output pages, one for each specific range of tasks. These include:

a bitmap image test that prints three images - two color and one black and white;

a graphics test that tests various graphics operators;

a font test that prints various available fonts;

a memory test that tests the speed of the printer RAM by copying variables from one part of memory to another;

a math test that tests the various mathematical operations; and

a final page containing the statistics for each of the other pages.

[http://www.gaaj.qc.ca/ppst/]
PPTP: The Point to Point Tunneling Protocol is used by Windows NT/95 platforms to create Virtual Private Networks (VPNs). It makes use of the Generic Routing and Encapsulation (GRE) protocol as defined in RFC 1701 and 1702.
[http://bmrc.berkeley.edu/people/chaffee/linux_pptp.html]
Pratt: A tool that searches for patterns conserved in a set of protein sequences. The kinds of patterns to be searched for can be specified as well as the number of sequences that should match a pattern. Other features include:

command line search control wherein values for all parameters can be specified on the command line;

use of upper- and lower-case symbols to differentiate sequences matching wildcard and non-wildcard positions;

extensive online help;

restriction of search areas;

input of multiple sequence alignments of some or all sequences in a set of protein sequences; and

use of branch-and-bound heuristics to make pattern searches more efficient.

A source code distribution of Pratt is available which is written in C and can be compiled on most platforms. A manual is available in HTML format.
[http://www.ii.uib.no/~inge/Pratt.html]
PRAXIS: A Fortran 77 function subroutine that returns the minimum of a function F(X,N) of N variables using the principal axis method. The gradient of the function is not required.
[http://www.netlib.org/opt/index.html]
PRCS: The Project Revision Control System is the front end to a set of tools that provide a way to deal with sets of files and directories as an entity to preserve coherent versions of entire sets. It presents the abstraction of named projects that have multiple versions, each consisting of a set of files arranged into a directory subtree. PRCS attempts to provide a much simpler model than similar packages like RCS or CVS.
The operations allowed by the software include creating a copy of the directory tree for a project version, creating a new project version, searching for differences between project versions, inserting changes that occurred between two project versions (i.e. merging), printing out information about project versions, adding or subtracting the files contained in a new project version, moving files from one subdirectory (i.e. version) to another, etc. PRCS keeps track of all checked-in project versions in a repository and locks them in only while it is actually running.
The source code of PRCS is available as are binaries for FreeBSD, HPUX, IRIX, Linux ELF, Solaris, SunOS and ULTRIX platforms. The present (9/96) documentation is contained within a hypertext document at the site (in HTML format).
[http://www.XCF.Berkeley.EDU/~jmacd/prcs.html]
PRECCX: The PREttier Compiler Compiler eXtended is an infinite-lookahead parser generator for context dependent grammars which generates ANSI C code. Specification scripts are in very extended BNF with inherited and synthetic attributes allowed. Scripts can be compiled in separate modules and later linked together, and meta-production rules are allowed. The technology is essentially LL(oo) with optimizations, and a converter for yacc scripts is available. Lexical analyzers such a lex and flex are suitable pre-filters for PRECCX and are called in the same way that yacc calls them.
A significant feature of PRECCX is the use of parameterized grammar definitions which allow context-dependent grammars. The higher order capability provided by parameterization and the modular arrangement of scripts make parser specifications much more maintainable. The infinite lookahead feature makes the semantics declarative, e.g. a non-terminal can be replaced by its definition without altering the semantics. A newer feature is that attributes can be synthesized on the fly and passed seamlessly into the parser, which extends the declarative programming paradigm from parameterized attribute grammar specifications to fully cover mixed and/or synthetic attributed grammars as well.
A distribution of PRECCX is available for Linux platforms. It is documented in a user's manual available in PostScript format.
[http://www.comlab.ox.ac.uk/archive/redo/precc.html]
PRECISE: The PRecision Estimation and Control In Scientific and Engineering computing package is a set of Matlab tools for setting up and performing computer experiments to explore the impact of finite precision on the quality of convergence of numerical methods. Numerical stability experiments are performed by a straightforward randomization of selected data, after which a sample of perturbed solutions (or spectra) and associated residuals are calculated. Complete statistical backward error analyses can also be performed on numerical methods.
The Matlab routines in PRECISE include:

rnorm, for normwise data perturbations;

rcomp, for componentwise data perturbations;

statinv_comp, for componentwise statistical studies of matrix inversion;

statinv_norm, for normwise statistical studies of matrix inversion;

statlu_comp, for componentwise statistical study of linear systems using LU factorization;

statlu_norm, for normwise statistical study of linear systems using LU factorization;

statqr_comp, for componentwise statistical study of the solution of linear systems using QR factorization;

statqr_norm, for normwise statistical study of the solution of linear systems using QR factorization;

graphlin, for the graphical display of experiment results;

stateig_norm, for normwise statistical study of eigenvalues;

grapheig, for graphical display of eigenvalue studies;

stat_newt, newt, pol, derpol, perpol, for componentwise statistical study of Newton iteration;

graphnewt, for graphical display of Newton experiment results;

pscomp, for componentwise perturbed spectra;

psnorm, for normwise perturbed spectra; and

portrait, couleur, resolv, forme, for obtaining and graphing the spectral portrait of a matrix.

[ftp://ftp.cerfacs.fr/pub/algo/software/Qualcomp/PRECISE/]
premail: A program for the transparent encryption of email whose goal is to add privacy and authentication to existing email clients with a minimum of fiddling while preserving a rich set of functionality including MIME-based multimedia data types. The features of premail include: creation and management of newnym style nyms, some support for S/MIME using RIPEM as the cryptographic engine, integration with Netscape 3.0, support for all cypherpunk remailers, support for Mixmaster remailers, encrypted and signed email including both preparation and decoding, support for the PGP/MIME standard, support for MOSS through TIS/MOSS 7.1, automatic selection of remailer chains, clean handling of ``cc:'' field and other such interactions, and more.
A source code distribution of premail is available. It is written in Perl and requires version 5 or greater. Documentation is available online.
[http://atropos.c2.net/~raph/premail.html]
PREP: A preprocessor for Fortran programs which is an alternative to RATFOR. The features include full macro facilities, a concise shorthand for array and vector statements, and support for all of the standard flow control constructs of Forth. The vector statement notation makes it possible to incorporate do loop unrolling automatically to any depth. The macro processor is a sort of pre-preprocessor for which the order of translation is file inclusion, macro processing, flow control extensions, and vector statements.
A source code distribution of PREP is available. It is written in portable C and can be compiled and used on most generic UNIX platforms. Its use is documented in a user's guide in ASCII format.
[http://sources.isc.org/devel/lang/prep.txt]
Preprocess: A preprocessor for C++ modules. The features include:

transformation of unit-style single source file C++ modules into three output files, i.e. a public header, a private header, and an implementation file;

automatic expansion of class declarations using member function definitions found in the input file;

automatic exporting of functions declared inline, along with all the functions and types they need; and

preservation of all comments.

The drawbacks include not understanding preprocessor constructs other than #include and no support for namespaces.
[http://os.inf.tu-dresden.de/~hohmuth/prj/preprocess/]
preprocessors: Available preprocessing languages and utilities include:

abc2mtex, can be used as a preprocessor for MusicTeX or MusiXTeX;

Basis, includes a Fortran preprocessor;

bibprep, a preprocessor for bibliographical records;

CHPP, a preprocessor originally designed for HTML but much more widely applicable;

cpp, a part of astkit that is a standalone preprocesssor for C;

doxygen, a documentation system with a full C preprocessor;

Dynace, a preprocessor for adding object-oriented features to C;

ELROS, a C preprocessor that produces remote operations from embedded statements;

EPP, an extensible Java preprocessor;

fastpictex, a preprocessor for PicTeX;

GCC, the GNU C compilation system;

gtml, an HTML preprocessor;

HMML, an HTML preprocessor;

HTE, an HTML preprocessor;

HTeX, a preprocessor for embedding LaTeX equations in HTML;

htmlpp, an HTML preprocessor;

igor, a configuration file preprocessor;

iPP, a general preprocessor written in Java;

MPP, a preprocessor for creating MPEG movies;

Ox, a yacc/lex/C preprocessor for bringing attribute grammars to mainstream UNIX;

PREP, a Fortran preprocessor;

Preprocess, a preprocessor for C++ modules;

RATC, a preprocessor for updating the control structures in C;

RATFOR, the classic Fortran preprocessor;

Reactive-C, a language implemented as a C preprocessor;

SEPlib, a package containing preprocessors for Fortran code;

WPP, an HTML preprocessor; and

Y, designed as a replacement for RATFOR.
PreScript: A utility that converts PostScript to plain ASCII or HTML. It first converts a PostScript document to plain text and then inserts rudimentary HTML tags to partly automate the conversion of PostScript documents into HTML. PreScript also determines the line spacing of a document and uses that and indentations to determine paragraph boundaries, removes hyphenations where needed, and detects and translates most ligatures. It is written in PostScript and Python and requires Ghostscript 4.01 or later and Python 1.3 or later.
[http://www.nzdl.org/technology/prescript.html]
presentation software: Package for creating transparencies and/or onscreen presentations for those inevitable and mostly useless meetings and conferences. Listed packages include:

EWIPE, a Tcl/Tk-based package for creating presentations

LaTeX, which has several macro packages for creating presentation slides;

Lout, which has a macro package for creating presentation slides;

Lyx, a front-end for LaTeX which makes using it somewhat easier for neophytes;

MagicPoint, for creating presentations on X11 screens and PostScript slides; and

xdvipresent, a system for creating slide presentations with LaTeX and X11.
Pretzel: A prettyprinter generator that creates modules for prettyprinting from the grammars for various languages including C, Pascal and Java.
[http://www.iti.informatik.th-darmstadt.de/
~gaertner/pretzel/]
PriMa: A printing filter that gives the user the ability to manipulate a document in various ways (e.g. change paper size, print only selected pages or ranges, print duplex, rearrange pages, etc.), to preview a document, and to send it to a file, a printer, mail, fax systems, or other programs. PriMa requires documents in PostScript format, but if they aren't it can use the MagicFilter package to convert a file to PostScript. PriMa is basically an interface built around the psutils package, and as such has all its capabilities.
A source code distribution of PriMa is available. It can be compiled and used on many UNIX flavors including Linux. Compilation requires the XForms library at version 0.86 or newer. It is documented in a README file available in both ASCII and PostScript formats.
[http://sunsite.unc.edu/pub/Linux/system/printing/]
printing utilities: A wide variety of software for enabling and handling the performance of various printing tasks is available for Linux platforms. Useful sites include:

Linux Printing HOWTO
[http://www.picante.com/~gtaylor/pht/]

The available packages include

APSL, a common printing API for GNU/Linux and other UNIX systems

a2ps, a filter for converting nearly any format to PostScript for printing;

CEPS, a printing system designed for medium to large networks;

CUPS, an implementation of the HTTP-based IPP

GNU enscript, a filter for converting text files into PostScript for printing;

FLpr, a script that unifies the usage of several other printing-related programs;

LPRng, an implementation of an LPD-protocol based print spooler;

nenscript, a filter for converting text files into PostScript for printing;

pdq, a straightforward and flexible print; subsystem;

PPR, a print spooler centered on PostScript jobs;

PriMa, a printing filter;

pup, a GUI utility for maintaining printers under Linux; and

rlpr, a network printing utility.
PRISS: The Portable RT[S]P Internet Streaming Server is, as the name indicates, a portable streaming Internet server based on Apple's Darwin Streaming Server. Source code and binary versions are available for Linux platforms.
[http://www.streamingserver.org/priss.html]
Privtool: A PGP-aware replacement for the standard Sun mailtool program with a similar user interface and automagick support for PGP-signing and PGP-encryption. Privtool displays a list of messages along with flags indicating whether they are signed or encrypted and if they have had their signatures verified or have been decrypted. Double-clicking on a message will automatically decrypt and display it (and will also check the signature if necessary). When composing or replying to a message, the resulting message can be digitally signed and/or encrypted. It can also use the Mixmaster anonymous remailer to send the message through one or more remailers.
The source code for Privtool is available at a European site which bypasses U.S. cryptography export regulations. It is known to work on Sun SunOS and Solaris, FreeBSD, and Linux Intel platforms. It is documented on the site as well as in documents in the distribution.
[http://www.unicorn.com/privtool/privtool.html]
PRL: The Programmer's Reusable Library is a family of compatible software libraries intended to promote software reuse. It consists of a layered set of seven libraries with a strong emphasis on computer graphics. These libraries provide a POSIX (POSIX) system interface, programming language primitive data types (PROGRLANG), graphical device drivers (DEVICE), low-level graphics (GRAPHICS), graphical function plotting (PLOT), graphical surface plotting (SURFACE), and graphical cartographic map plotting (MAP).
The seven libraries provide a wide array of capabilities.

The POSIX library is a general purpose Fortran-callable library which provides application programs with access to POSIX functions.

The PROGRLANG library is intended to provide useful operations on Fortran primitive data types as a supplement to the standard set of Fortran intrinsic functions.

The DEVICE library provides a standardized interface to graphics output devices in support of the GRAPHICS library. Currently (4/97) supported devices include DEC LN03, HP LaserJet, PostScript (Level I and II), Tektronix (4014, 4115, 4107, and 4510), X terminal, and Vector Save file format.

The GRAPHICS library provides fundamental 2-D graphics capabilities such as line drawing and graphical text generation. It also supports graphics attributes such as color, line style, line thickness, character shading, and area blanking.

The PLOT library supports the production of 2-D and 3-D function plots. Supported plot types include: 2-D linear, log, log-linear, and polar plots; 2-D bar and pie charts; and 3-D linear and spherical plots.

The SURFACE library supports the production of 2-D and 3-D surface plots. Supported plot types are: 2-D surface line contour and color-shaded contour plots; 3-D surface mesh wireframe (with and without hidden line removal); 3-D surface line contour plots; and 3-D color-shaded contour plots.

The MAP library supports the production of 2-D cartographic projection plots. It currently supports Lambert Equal Area and Cylindrical Equidistant projections and provides two cartographic data bases of the Earth, i.e. low and high resolution databases.

The PRL is available for several platforms and as of 12/15/95 was freely available in binary form for Linux platforms. A user's manual and reference guide in PostScript format are included in the distribution.
[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
[http://isis.iah.com/oa/]
PRM: The Prospero Resource Manager enables users to run sequential or parallel applications on a network of workstations. Sequential jobs are offloaded to lightly loaded processors while parallel jobs use some or all of the processor collection to achieve speedups in execution time. The parallel applications are based on the message passing model and are linked with a communication library which provides routines for sending and receiving tagged messages, broadcasting, and global synchronization. The interfaces available are the CM-5 CMMD library and a PVM interface, both of which allow the development of applications without having to modify any source code for use with PRM. The resource allocation functions of PRM are distributed across three entities: system managers which control access to a collection of processing resources and allocates them to jobs as requested by job managers; job managers which acquire processing nodes from system managers and initiate tasks on these nodes through node managers; and node managers which initiate and monitor tasks on the nodes on which they're running.
The features of PRM include:

utility programs to checking the status of running jobs, query the status of a system manager and the nodes it manages, and to gracefully shut down a PRM system;

the use of an access control list (ACL) to determine whether the host requesting resources is authorized;

library routines for standard I/O tasks and for task creation and resource management;

the checkpoint and migration of tasks to other nodes when the current node makes itself unavailable; and

application debugging.

A source code distribution of PRM is available. It is written in C and should compile and install on many generic UNIX platforms on which PVM is installed. The documentation includes a user's manual and several technical papers, all available in PostScript format.
[http://nii-server.isi.edu/gost-group/products/prm/]
PRMS: The Precipitation-Runoff Modeling System is a modularly-designed, deterministic, distributed-parameter modeling system developed to evaluate the impacts of various combinations of precipitation, climate, and land use on streamflow, sediment yields, and general basin hydrology. Basin response to normal and extreme rainfall and snowmelt can be simulated to evaluate changes in water-balance relationships, flow regimes, flood peaks and volumes, soil-water relationships, sediment yields, and ground-water recharge. Parameter optimization and sensitivity analysis capabilities are provided to fit selected model paramters and evaluate their individual and joint effects on model output.
PRMS divides a watershed into subunits based on basin characteristics such as slope, aspect, elevation, vegetation type, soil type, land use, and precipitation distribution. Two levels of partitioning are available, with the first dividing the basin into homogeneous response units (HRU) based on basin characteristics. The sum of responses for all HRUs, weighted on a unit area basis, produces the daily system response and streamflow for a basin. The second partitioning level is used for storm hydrograph simulation. In this level the watershed in conceptualized as a series of interconnected flow planes and channel segments. Surface runoff is routed over the flow planes and into the channel segments, and channel flow is routed through the watershed channel system. An HRU can be either the equivalent of a flow plane or can be separated into a number of flow planes.
A source code distribution of PRMS for UNIX platforms is available. The primary documentation is contained within Leavesley et al. (1983). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/prms.html]
[http://www.geogr.uni-jena.de/software/prms.html]
PRNGlib: The Parallel Random Number Generator library provides several pseudo-random number generators via a common interface on any shared or distributed memory parallel architecture. Common routines are specified to initialize the generators with appropriate seeds on each processor and to generate uniform, normal, Poisson or exponential distributed random vectors. Lagged Fibonacci, generalized shift register, and multiplicative linear congruential generators are implemented with almost arbitrary specifications for lags, multipliers, moduli, etc. Also included in the package are a set of support routines, test routines, and example programs parallelized using the MPI library. The library is documented via a user's manual in PostScript format.
[ftp://ftp.cscs.ch/pub/CSCS/libraries/PRNGlib/]
procmail: A powerful set of tools which enable the automatic processing of mail either as it is received or after it is already in a message folder. The package consists of three programs: procmail, formail, and lockfile.
The features of the procmail program include:

small size, easy installation and simple to maintain and configure;

event driven invokation and no use of temporary files;

use of standard egrep regular expressions;

low use of system resources;

easy yes-no decisions on where the mail should go;

neural net type weighted scoring of mail messages;

reliably filtering, delivering, and forwarding mail;

a reliable hook for starting any programs or shell scripts upon mail arrival;

good performance under bad system conditions;

absolutely undeliverable mail is bounded back to the sender;

reliable mailbox locking across NFS;

support for four mailfolder standards;

provision of a mail log file chock full of gory details;

display of a wide variety of diagnostic and error message (using the mail log);

no limits on line length, mail length, or the use of any character;

secure system mailbox handling;

provision for controlled execution of programs and scripts from the alias file;

allowing for shifting of system mailboxes into home directories;

clock skew immunity; and

works with sendmail, ZMailer, smail, MMDF, and mailsurr.

The formail program features include

generation of auto-reply headers;

conversion of mail into standard mailbox format (for processing with a standard mail program);

splitting up mailboxes, digests, and saved articles into individual messages;

simple header munging/extraction;

extraction of messages from mailboxes; and

recognition of duplicate messages.

The lockfile program provides NFS-secure lockfiles to shell script programmers and gives normal users to ability to lock their system mailbox regardless of the permissions on the mail-spool directory.
The source code for the procmail package, written in C, is available on can be installed on most generic UNIX platforms (since the code is POSIX, ANSI C and K&R conforming). The documentation is contained within a veritable ocean of man pages.
[http://www.procmail.org/]
[http://www.best.com/~ii/internet/robots/procmail/]

filtmail

An extensible email filtering package developed to circumvent the limitations and arcane syntax of procmail (although it still requires and uses the latter). The packages includes several filters including those for addresses, the domain of the sender, the login of the sender, phrases in the message content, bogus domains, and phrases in the subject line. A vacation filter is also included. A source code distribution of this Perl package is available.
[http://www.best.com/~pjl/software.html]

procmail-lib

A collection of procmail scripts for building an advanced mail handling system. The scripts include:

ackmail.rc, a set of recipes for performing auto-acknowledgement of incoming mail;

commands.help, a file of information sent in response to mail requests for information;

commands.rc, a set of recipes which recognize commands in the Subject header and perform them;

dupcheck.rc, a recipe file which removes duplicate mail;

get-from.rc, a recipe file which extracts the best address from the various originating address fields;

guess-mua.rc, a recipe file which attempts to guess the current MUA;

headers.rc, which defines some variables which can be used for matching against headers; and

unread-mh.rc, a recipe file which attempts to compute how many unread messages there are for an MH user.

[http://www.fr.debian.org/Packages/unstable/mail/procmail-lib.html]
procps: This package consists of a library which parses the textual /proc filesystem and a suite of utilities which uses the library. The utilities are:

ps, which gives a snapshot of the current system processes;

uptime, which tells how long the system's been running;

w</