/vak`soh-sen'trizm/ [analogy with
`ethnocentrism'] n. A notional disease said to afflict
C programmers who persist in coding according to certain
assumptions that are valid (esp. under UNIX) on VAXen
false elsewhere. Among these are
1. The assumption that dereferencing a null pointer is safe because it
is all bits 0, and location 0 is readable and 0. Problem this may
instead cause an illegal-address trap on non-VAXen, and even on
VAXen under OSes other than BSD UNIX. Usually this is an implicit
assumption of sloppy code (forgetting to check the pointer before
using it), rather than deliberate exploitation of a misfeature.)
2. The assumption that characters are signed.
3. The assumption that a pointer to any one type can freely be cast
into a pointer to any other type. A stronger form of this is the
assumption that all pointers are the same size and format, which
means you don't have to worry about getting the types correct in
calls. Problem this fails on word-oriented machines or others
with multiple pointer formats.
4. The assumption that the parameters of a routine are stored in
memory, contiguously, and in strictly ascending or descending
order. Problem this fails on many RISC architectures.
5. The assumption that pointer and integer types are the same size,
and that pointers can be stuffed into integer variables (and
vice-versa) and drawn back out without being truncated or mangled.
Problem this fails on segmented architectures or word-oriented
machines with funny pointer formats.
6. The assumption that a data type of any size may begin at any byte
address in memory (for example, that you can freely construct and
dereference a pointer to a word- or greater-sized object at an odd
char address). Problem this fails on many (esp. RISC)
architectures better optimized for HLL
execution speed, and can
cause an illegal address fault or bus error.
7. The (related) assumption that there is no padding at the end of
types and that in an array you can thus step right from the last
byte of a previous component to the first byte of the next one.
This is not only machine- but compiler-dependent.
8. The assumption that memory address space is globally flat and that
the array reference `foo[-1]' is necessarily valid. Problem