When a large or frequently-updated program must be ported to or from Plan 9, the ANSI/POSIX environment known as APE can be useful. APE combines the set of headers and object code libraries specified by the ANSI C standard (ANSI X3.159-1989) with the POSIX operating system interface standard (IEEE 1003.1-1990, ISO 9945-1), the part of POSIX defining the basic operating system functions. Using APE will cause slower compilation and marginally slower execution speeds, so if the importing or exporting happens only infrequently, due consideration should be given to using the usual Plan 9 compilation environment instead. Another factor to consider is that the Plan 9 header organization is much simpler to remember and use.
There are some aspects of required POSIX behavior that are impossible or very hard to simulate in Plan 9. They are described below. Experience has shown, however, that the simulation is adequate for the vast majority of programs. A much more common problem is that many programs use functions or headers not defined by POSIX. APE has some extensions to POSIX to help in this regard. Extensions must be explicitly enabled with an appropriate #define, in order that the APE environment be a good aid for testing ANSI/POSIX compliance of programs.
The pcc command acts as a front end to the Plan 9 C compilers and loaders. It runs an ANSI C preprocessor over source files, using the APE headers to satisfy #include <file> directives; then it runs a Plan 9 C compiler; finally, it may load with APE libraries to produce an executable program. The document How to Use the Plan 9 C Compiler explains how environment variables are used by convention to handle compilation for differing architectures. The environment variable $objtype controls which Plan 9 compiler and loader are used by pcc, as well as the location of header and library files. For example, if $objtype is mips, then pcc has cpp look for headers in /mips/include/ape followed by /sys/include/ape; then pcc uses vc to create .v object files; finally, vl is used to create an executable using libraries in /mips/lib/ape.
The pcc command is intended for uses where the source code is ANSI/POSIX, but the programs are built in the usual Plan 9 manner with mk and producing object files with names ending in .v, etc. Sometimes it is best to use the standard POSIX make and cc (which produces object files with names ending in .o, and automatically calls the loader unless -c is specified). Under these circumstances, execute the command:
ape/psh
The cc command accepts the options mandated for the POSIX command c89, as specified in the C-Language Development Utilities Option annex of the POSIX Shell and Utilities standard. It also accepts the following nonstandard options: -v for echoing the commands for each pass to stdout; -A to turn on ANSI prototype warnings; -S to leave assembly language in file.s; -Wp,args to pass args to the cpp; -W0,args to pass args to 2c, etc.; and -Wl,args to pass args to 2l, etc.
The sh command is pdksh, a mostly POSIX-compliant public domain Korn Shell. The Plan 9 implementation does not include the emacs and vi editing modes.
The stty command only has effect if the ape/ptyfs command has been started to interpose a pseudo-tty interface between /dev/cons and the running command. None of the distributed commands do this automatically.
The C and POSIX standards require that certain symbols be
defined in headers.
They also require that certain other classes of symbols not
be defined in the headers, and specify certain other
symbols that may be defined in headers at the discretion
of the implementation.
POSIX defines
feature test macros,
which are preprocessor symbols beginning with an underscore
and then a capital letter; if the program
#defines
a feature test macro before the inclusion of any headers,
then it is requesting that certain symbols be visible in the headers.
The most important feature test macro is
_POSIX_SOURCE:
when it is defined, exactly the symbols required by POSIX are
visible in the appropriate headers.
Consider
To export a program, it helps to know whether it fits in one of the following categories:
With APE, if headers are always included to declare any library functions
used, then the set of feature test macros defined by a program will
show which of the above categories the program is in.
To accomplish this, no symbol is defined in a header if it is not required
by the C or POSIX standard, and those required by the POSIX standard
are protected by
#ifdef _POSIX_SOURCE.
For example,
Pcc and cc do not predefine any preprocessor symbols except those required by the ANSI C standard: __STDC__, __LINE__, __FILE__, __DATE__, and __TIME__. Any others must be defined in the program itself or by using -D on the command line.
The discipline enforced by putting only required names in the headers is useful for exporting programs, but it gets in the way when importing programs. The compromise is to allow additional symbols in headers, additional headers, and additional library functions, but only under control of extension feature test macros. The following extensions are provided; unless otherwise specified, the additional library functions are in the default APE library.
Some large systems, including X11, have been ported successfully to Plan 9 using APE (the X11 port is not included in the distribution, however, because supporting it properly is too big a job). The problems encountered fall into three categories: (1) non-ANSI C/POSIX features used; (2) inadequate simulation of POSIX functions; and (3) compiler/loader bugs. By far the majority of problems are in the first category.
POSIX is just starting to be a target for programmers.
Most existing code is written to work with one or both of a BSD or a System V Unix.
System V is fairly close to POSIX, but there are some differences.
Also, many System V systems have imported some BSD features that are
not part of POSIX.
A good strategy for porting external programs is to first try using
CFLAGS=-D_POSIX_SOURCE;
if that doesn't work, try adding
_D_BSD_EXTENSION
and perhaps include
The second class of problems has to do with inadequacies in the Plan 9 simulation of POSIX functions. These shortcomings have rarely gotten in the way (except, perhaps, for the link problem).