C preprocessor features:

(1)	The preprocessor is centered around the libpp.a  library.  This
	library provides a tokenizing implementation of the preprocessing
	stages of ANSI standard C.  The same library is used to construct
	a standalone prepreprocessor as well as a C compiler front end
	that, compiled with the library, eliminates the need for a
	separate preprocessing pass.  Other C tools requiring C tokenizing
	can use this library, providing a common interface to C language
	tokens.

(2)	The #pragma interface is exploited to allow the addition of new
	directives and #pragma's without changing the preprocessor
	executable.  Most implementation details can be specified by
	directives in the file "ppdefault.h" that is automatically included
	(by the standalone cpp library wrapper) as an initialization step.

(3)	#assert, #unassert and corresponding #if predicate tests have been
	added to relieve the conflicts introduced by predefined #define
	macros (e.g., unix, vax, u3b, ...).  This is the same feature
	present in the extended Reiser cpp that has been included in the
	nmake distribution. (NOTE: #assert is a failed experiment)

(4)	The implementation is sensitive to the incompatible differences
	between the Reiser cpp (used by AT&T and BSD compilers) and the new
	ANSI standard C.  A compatibility dialect implements Reiser
	features, allowing for a smooth transition to the ANSI standard.

(5)	To aid in the transition to ANSI, the preprocessor can do some
	operations that would normally be done by the lexical analysis
	stage of a compiler front end:
	
	(a)	convert new-style character constants to a form
		recognized by all current compilers

	(b)	concatenate adjacent string literals

(6)	The preprocessor can also warn about obsolete constructs used
	in the compatibility dialect and on non-standard constructs
	used in the ANSI dialect.  The latter is useful in writing
	C code that is made to run through other implementations of
	ANSI standard C.

(7)	The preprocessor allows a C language implementor to take
	advantage of local extensions without invalidating the
	conformance of the C language implementation.

C9X additions:

(1)	#pragma STDC ...
		special forms always accecpted

(2)	_Pragma unary operator for pragmas via macro expansion
		_Pragma(string-literal)
			#pragma a b c
			_Pragma("a b c")

(3)	keywords
		restrict inline _Bool _Complex _Imaginary

(4)	macros
		__STDC_VERSION__ 		199901L
		__STDC_IEC_559__		1 or undef
		__STDC_IEC_559_COMPLEX__	1 or udef
		__STDC_ISO_10646__		yyyymmL

(5)	empty arguments allowed in function-like macros

(6)	variable arguments via ...
		__VA_ARGS__ in replacement list only, expands to var args
		only var args is ok (shall only appear in ...)

(7)	hex floating constant with binary exponents
		xxxxxx[pP]dddd

(8)	// style comments

(9)	universal characters, even in identifiers!
		\uxxxx \Uxxxxxxxx

(10)	LL ll ULL ull suffix for long long literals

(11)	<stdarg.h> has va_copy()
