1.1 Machine Addresses
Felix provides some types which are used to manipulate machine addresses and memory at a low level.
address is basically a C
However, you can add or subtract an integer from an address,
as if it were actually a C
unsigned char*, and of course
you can also just increment or decrement an addess.
Addition of an integer to an address is modular, that is, the addition may cause wrap around like an unsigned integer type.
Addresses are totally ordered and support the usual comparisons however addition is not confluent with comparisons:
x > y does not imply x + 1 > y + 1
You can also subtract two addresses, the result is of type
This is a signed integer type with the same number of values as
there are addresses. If the addresses are close and the first address
is larger than the second the result is positive, negative if they're
ordered the other way. If the addresses are a long way apart, in particular
more than half the total number of addres value distant, then the difference
goes through the maximum value to the zero value and the sign is the
opposite of what is expected. In particular the absolute value
of the difference is the shortest distance between the addresses
around the address circle.
Therefore, the difference operation is also not confluent with comparisons, that is,
x < y does not imply y - x > 0
In particular if
x is very small, and
y is very big then
y-x > 0, the
ptrdiff will instead be a
small negative value.
To solve this problem Felix also provides two more types:
uintptr which support the same number of values
as an address:
intptr is identical to
uintptr is unsigned.
Casting a pointer difference to
uintptr is confluent with comparisons.
y > x then
(y-x).uintptr is precisely the mathematical value
of the difference. If the pointers are reversed the value is the mathematical
result (which is negative) added to the number of values (one more than the
Addresses cannot be dereferenced.
An address can be obtained from any pointer or integer. You can also cast an address to any pointer type, the onus is on you, the programmer, to ensure the address actually pointers to store containing a value of that type.
supports the same operations as an address except it can be dereferenced.