bearophile wrote:
...
A possible use is for runtime test for overflows: you can perform operations
among 64 bit integers with 128 bit precision, and then you can look at the
result if it fits still in 64 bits. If not, you can raise an overflow exception
(probably there other ways to test for overflow, but this seems simple to
implement). You can use 64 bits to implement the safe operations among 32-16-8
bit numbers on the 64 bit CPUs).
Bye,
bearophile
It's always annoyed me that the CPU goes to all the trouble of doing
multiplies in 64-bit, keeping track of overflows, etc., and yet there's
no way in any language I've ever seen (aside from assembler) to get that
information.
Personally, rather than working around the problem with 128-bit types,
I'd prefer to see something (roughly) like this implemented:
bool overflow;
ubyte high;
ubyte a = 128;
// overflow == false
pragma(OverflowFlag, overflow) ubyte c = a + a;
// overflow == true
// high == 0
pragma(ResultHigh, high) ubyte d = a * 2;
// high == 1, d == 0
As for 128-bit types themselves, I'm sure *someone* would find a use for
them, and they'd be their favourite feature. Personally, I prefer
arbitrary-precision once you start getting that big, but there you go.
-- Daniel
