1.1 Machine Addresses

Felix provides some types which are used to manipulate machine addresses and memory at a low level.

The type address is basically a C void*. 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 ptrdiff. 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 whilst mathematically y-x > 0, the ptrdiff will instead be a small negative value.

To solve this problem Felix also provides two more types: intptr and uintptr which support the same number of values as an address: intptr is identical to ptrdiff whereas uintptr is unsigned.

Casting a pointer difference to uintptr is confluent with comparisons. If 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 maximum).

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.

The type

  &byte

supports the same operations as an address except it can be dereferenced.