Peter Smithson wrote:

> I'd get your money back on the C compiler that did that - there's no
> difference between byte and non-byte addresses in C.  I've only come
> across
> the concept in SPL on MPE and I've used C on about 10 different UNIX
> platorms, Windows, MPE and AS400.
>
> It does get rid of the warnings though so I do use casting anyway.

This is not true of C in general, just C on most machines.  The C
standard requires those casts for a reason. From an old USENET C FAQ:

5.17:   Seriously, have any actual machines really used nonzero null
        pointers, or different representations for pointers to different
        types?

The Prime 50 series used segment 07777, offset 0 for the null pointer,
at least for PL/I.  Later models used segment 0, offset 0 for null
pointers in C, necessitating new instructions such as TCNP (Test C Null
Pointer), evidently as a sop to all the extant poorly-written C code
which made incorrect assumptions.  Older, word-addressed Prime machines
were also notorious for requiring larger byte pointers (char *'s) than
word pointers (int *'s).

The Eclipse MV series from Data General has three architecturally
supported pointer formats (word, byte, and bit pointers), two of which
are used by C compilers: byte pointers for char * and void *, and word
pointers for everything else.

Some Honeywell-Bull mainframes use the bit pattern 06000 for (internal)
null pointers.

The CDC Cyber 180 Series has 48-bit pointers consisting of a ring,
segment, and offset.  Most users (in ring 11) have null pointers of
0xB00000000000.  It was common on old CDC ones- complement machines to
use an all-one-bits word as a special flag for all kinds of data,
including invalid addresses.

The old HP 3000 series uses a different addressing scheme for byte
addresses than for word addresses; like several of the machines above it
therefore uses different representations for char * and void * pointers
than for other pointers.

The Symbolics Lisp Machine, a tagged architecture, does not even have
conventional numeric pointers; it uses the pair <NIL, 0> (basically a
nonexistent <object, offset> handle) as a C null pointer.

Depending on the "memory model" in use, 8086-family processors (PC
compatibles) may use 16-bit data pointers and 32-bit function pointers,
or vice versa.

Some 64-bit Cray machines represent int * in the lower 48 bits of a
word; char * additionally uses the upper 16 bits to indicate a byte
address within a word.

* To join/leave the list, search archives, change list settings, *
* etc., please visit http://raven.utc.edu/archives/hp3000-l.html *