This is a quite advanced topic, but might be the cause of some strange bugs in your programs.
Basically, E does not have a way of differentiating signed and unsigned values from, say, the
That is, all values from the 32-bit,
LONG type are considered to be signed values, so the range of values is from -2,147,483,648 to 2,147,483,647.
If the values from this type were taken to be unsigned then no negative values would be allowed but more positive values would be possible (i.e., the range of values would be from zero to 4,294,967,295).
This distinction would also affect the mathematical operators.
In practice, though, it is not the
LONG type that can cause problems.
Instead, it is the 16-bit,
INT type, which again is considered to be signed.
This means that the range of values is -32,768 to 32,767.
However, the Amiga system objects contain a number of 16-bit,
INT elements which are actually interpreted as unsigned, ranging from zero to 65,535.
A prominent example is the proportional gadget which forms a part of a scroll-bar on a window (for example, a drawer window on Workbench).
This works with unsigned 16-bit values, which is at odds with the
INT type in E.
These values are commonly used in calculations to determine the position of something displayed in a window, and if the
INT type is used without taking into account this signed/unsigned problem the results can be quite wrong.
Luckily it is very simple to convert the signed
INT values into unsigned values if they are part of some expression, since the value of any expression is taken from the
LONG type (and unsigned
INT values fit well within the range of even signed
PROC unsigned_int(x) IS x AND $FFFF
unsigned_int, above, is very specific to the way the Amiga handles values internally, so to understand how it works is beyond the scope of this Guide.
It should be used wherever an unsigned 16-bit value is stored in an
INT element of, say, an Amiga system object.
For example, the position of the top of a (vertical) proportional gadget as a percentage (zero to one hundred) of its size can be calculated like this:
/* propinfo is from the module 'intuition/intuition' */ DEF gad:PTR TO propinfo, pct /* Set up gad... */ /* Calculate percentage (MAXPOT is from 'intuition/intuition') */ pct:=Div(Mul(100,unsigned_int(gad.vertpot)),MAXPOT)
Notice that the full 32-bit functions
Mul need to be used since the arithmetic may be well over the normal 16-bits used in the `/' and `*' operators.
The remaining type,
CHAR, is not, in practice, a problem.
It is the only unsigned type, with a range of values from zero to 255.
There is a fairly simple way to convert these values to signed values (and again this is particular to the way the Amiga stores values internally).
One good example of a signed
CHAR value is the priority value associated with a node of an Amiga list (i.e., the
pri element of an
ln object from the module `exec/nodes').
PROC signed_char(x) IS IF x<128 THEN x ELSE x-256
Go to the Next or Previous section, the Detailed Contents, or the Amiga E Encyclopedia.